Update app.py

app.py

@@ -1,5 +1,4 @@
 import gradio as gr
-import docx
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from google import generativeai as genai
@@ -9,7 +8,7 @@ from typing import List, Dict, Optional
 import os
 from pathlib import Path
 import time
-import fitz
+# The docx and fitz imports are no longer needed for the core logic
 
 GRADING_RUBRIC = """
 GRADING RUBRIC (Total 100 points)
@@ -82,49 +81,26 @@ Professor's Summary:
 
 """
 
+# The prompt is now simpler, as the files are passed as arguments to the model, not as text.
 BASE_PROMPT_TEMPLATE = """
 You are about to assume a role. Carefully review the persona, context, task, and output requirements before proceeding.
 
 1. PERSONA
-
 You are Dr. Stone, a meticulous and experienced Associate Professor of Nursing at a major university. You have been teaching for over 20 years, with a specialization in medical-surgical nursing. You are known for your high standards, particularly regarding academic integrity and the strict application of the American Psychological Association (APA) 7th Edition formatting guidelines. Your feedback is always direct, precise, and aimed at preparing students for the rigorous documentation standards required in the healthcare profession. Your tone is professional, authoritative, and educational. You do not offer praise for meeting baseline expectations; you simply state that the requirements have been met. Your criticism is specific, referencing the exact rule or rubric criterion that was violated.
 
 2. CONTEXT
-
-You are grading an essay for your undergraduate course, NURS 310: Fundamentals of Nursing. The assignment is an essay on the topic of "Skin Lesions." Students were provided with a detailed grading rubric, which you must follow perfectly and without exception. The total possible score for this assignment is 100 points.
+You are grading an essay for your undergraduate course, NURS 310: Fundamentals of Nursing. The assignment is an essay on the topic of "Skin Lesions." You will be provided with the student's paper as an attached file, and optionally an example paper file for reference.
 
 3. PRIMARY TASK
-
-Your task is to receive a student's essay submission and grade it with absolute precision according to the provided rubric. You must function as a perfect and unflinchingly accurate grader. There is no room for subjective interpretation or leniency. You will identify every error in content, formatting, spelling, grammar, and citation, and assign points strictly based on the rubric's quantitative thresholds.
+Your task is to analyze the attached student paper file and grade it with absolute precision according to the provided rubric. You must function as a perfect and unflinchingly accurate grader. There is no room for subjective interpretation or leniency. You will identify every error in content, formatting, spelling, grammar, and citation, and assign points strictly based on the rubric's quantitative thresholds.
 
 Your output should be a single JSON format structure response as indicated by the example below.
 
 **DO NOT** provide any introductory text, conversational pleasantries, or explanations outside of the requested JSON structure. Your entire response must be a single, valid JSON object.
 
-**Use the following rubric to grade the essay:**
+**Use the following rubric to grade the attached student paper:**
 {GRADING_RUBRIC}
 
-**For your reference, here is an example of a perfectly formatted paper. Use it as a guide for what correct formatting looks like:**
----
-**EXAMPLE PAPER START**
-{EXAMPLE_PAPER}
-**EXAMPLE PAPER END**
----
-
-**Instructions:**
-1.  Read the entire essay provided below.
-2.  Assess the essay against each category in the rubric.
-3.  Calculate the total points lost and the final grade out of 100.
-4.  Provide brief, specific comments explaining why points were deducted in each category.
-5.  Write a 2-3 sentence summary of the overall grade.
-6.  Format your entire output as a single JSON object with the following keys and value types:
-    - `finalGrade`: (Integer) The final score from 0-100.
-    - `pointDeductions`: (Object) An object where keys are the main rubric categories ("Content & Analysis", "Organization & Structure", "APA Formatting & Citations", "Clarity & Mechanics") and values are the integer number of points lost for that category.
-    - `feedback`: (Object) An object with the same keys as `pointDeductions`, where values are brief string comments explaining the point deductions for that category. If no points are lost, the comment should be "No points deducted."
-    - `summary`: (String) A 2-3 sentence summary of the paper's performance and the rationale for the grade.
-
-Do not deviate from this format.
-
 **Example of the required JSON output format:**
 {{
   "finalGrade": 88,
@@ -142,13 +118,8 @@ Do not deviate from this format.
   }},
   "summary": "This is a strong paper with excellent critical analysis. The final grade was primarily impacted by significant APA formatting errors, which should be the main focus for improvement."
 }}
-
----
-**ESSAY TO GRADE:**
-
 """
 
-
 @dataclass
 class GradingResult:
     """Holds the structured result of a single graded essay."""
@@ -160,94 +131,43 @@ class GradingResult:
     summary: Optional[str] = None
     error_message: Optional[str] = None
 
-
 # --- Core Logic Classes ---
-
-class EssayParser:
-    """Parses text content from a .docx file."""
-    @staticmethod
-    def parse_docx(file_path: str) -> str:
-        """Extracts all text from a Word document."""
-        try:
-            doc = docx.Document(file_path)
-            return "\n".join([para.text for para in doc.paragraphs if para.text])
-        except Exception as e:
-            # Handles cases where the file is corrupted or not a valid docx
-            raise IOError(
-                f"Could not read file: {os.path.basename(file_path)}. Error: {e}")
-
-    @staticmethod
-    def parse_pdf(file_path: str) -> str:
-        """Extracts all text from a PDF document."""
-        try:
-            doc = fitz.open(file_path)
-            text = ""
-            for page in doc:
-                text += page.get_text()
-            return text
-        except Exception as e:
-            raise IOError(
-                f"Could not read PDF file: {os.path.basename(file_path)}. Error: {e}")
-
-
+# EssayParser class is no longer needed and has been removed.
 
 class GeminiGrader:
     """Manages interaction with the Google Gemini API for grading."""
-
     def __init__(self, api_key: str):
         """Initializes the Gemini model."""
         try:
             genai.configure(api_key=api_key)
-            # Configuration for safer, more deterministic output
-            generation_config = {
-                "temperature": 0.1,
-                "top_p": 0.95,
-                "top_k": 40,
-            }
-            # Safety settings to prevent the model from refusing to grade
-            safety_settings = [
-                {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-                {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-                {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-                    "threshold": "BLOCK_NONE"},
-                {"category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-                    "threshold": "BLOCK_NONE"},
-            ]
-            self.model = genai.GenerativeModel(
-                model_name="gemini-1.5-pro-latest",
-                generation_config=generation_config,
-                safety_settings=safety_settings
-            )
+            self.model = genai.GenerativeModel(model_name="gemini-1.5-pro-latest")
         except Exception as e:
             raise ValueError(f"Failed to configure Gemini API: {e}")
 
-    def grade_essay(self, essay_text: str, file_name: str, example_paper_text: str) -> GradingResult:
+    def grade_essay(self, student_paper_file: object, example_paper_file: Optional[object]) -> GradingResult:
         """
-        Sends the essay to Gemini for grading and parses the JSON response.
-        This is a synchronous method designed to be run in a thread pool.
+        Sends files to Gemini for grading and parses the JSON response.
+        This method now takes API file objects directly.
         """
-        # Inject the rubric and the example paper text into the main prompt template
-        final_prompt = BASE_PROMPT_TEMPLATE.format(
-            GRADING_RUBRIC=GRADING_RUBRIC,
-            EXAMPLE_PAPER=example_paper_text
-        )
+        prompt_text = BASE_PROMPT_TEMPLATE.format(GRADING_RUBRIC=GRADING_RUBRIC)
+        
+        # Build the content list for the API call
+        # It includes the prompt text and the file objects
+        content_list = [prompt_text, student_paper_file]
+        if example_paper_file:
+            content_list.append(example_paper_file)
         
-        prompt_with_essay = f"{final_prompt}\n{essay_text}"
         try:
-            response = self.model.generate_content(prompt_with_essay)
-            # Clean the response to ensure it's valid JSON
+            response = self.model.generate_content(content_list)
             cleaned_response = response.text.strip().replace("```json", "").replace("```", "")
             data = json.loads(cleaned_response)
 
-            # Validate the structure of the returned JSON
-            required_keys = ["finalGrade",
-                             "pointDeductions", "feedback", "summary"]
+            required_keys = ["finalGrade", "pointDeductions", "feedback", "summary"]
             if not all(key in data for key in required_keys):
-                raise KeyError(
-                    "The model's response was missing one or more required keys.")
+                raise KeyError("Model response missing required keys.")
 
             return GradingResult(
-                file_name=file_name,
+                file_name=student_paper_file.display_name,
                 success=True,
                 grade=data["finalGrade"],
                 deductions=data["pointDeductions"],
@@ -256,163 +176,139 @@ class GeminiGrader:
             )
         except json.JSONDecodeError:
             return GradingResult(
-                file_name=file_name,
+                file_name=student_paper_file.display_name,
                 success=False,
-                error_message="Failed to parse the model's response. The output was not valid JSON."
+                error_message="Failed to parse the model's JSON response."
             )
         except Exception as e:
             return GradingResult(
-                file_name=file_name,
+                file_name=student_paper_file.display_name,
                 success=False,
                 error_message=f"An API or model error occurred: {str(e)}"
             )
 
-
 # --- Gradio Application ---
 
+def process_single_file(file_path: str, grader: GeminiGrader, example_paper_file_obj: Optional[object]) -> GradingResult:
+    """
+    Uploads a single student paper and calls the grader.
+    This function is what runs in each thread of the ThreadPoolExecutor.
+    """
+    student_paper_file_obj = None
+    try:
+        # Upload the student paper file for this specific job
+        student_paper_file_obj = genai.upload_file(path=file_path, display_name=os.path.basename(file_path))
+        return grader.grade_essay(student_paper_file_obj, example_paper_file_obj)
+    except Exception as e:
+        return GradingResult(file_name=os.path.basename(file_path), success=False, error_message=str(e))
+    finally:
+        # Clean up the uploaded student paper file after processing
+        if student_paper_file_obj:
+            genai.delete_file(student_paper_file_obj.name)
+
 async def grade_papers_concurrently(
     files: List[gr.File], example_paper_file: gr.File, api_key: str, progress=gr.Progress(track_tqdm=True)
 ) -> (str, str):
     """
     The main asynchronous function that orchestrates the grading process.
-    It's triggered by the Gradio button click.
     """
     start_time = time.time()
-
     if not api_key:
         raise gr.Error("Google API Key is required.")
     if not files:
-        raise gr.Error("Please upload at least one Word document.")
-
-    # Process the optional example paper
-    example_paper_text = "No example paper provided."
-    if example_paper_file:
-        try:
-            progress(0, desc="Parsing example paper...")
-            example_paper_text = EssayParser.parse_pdf(example_paper_file.name)
-        except IOError as e:
-            raise gr.Error(f"Failed to process example PDF: {e}")
+        raise gr.Error("Please upload at least one paper to grade.")
 
+    example_paper_file_obj = None
     try:
         grader = GeminiGrader(api_key)
-    except ValueError as e:
-        raise gr.Error(str(e))
-
-    file_paths = [file.name for file in files]
-    total_files = len(file_paths)
-
-    # Use a ThreadPoolExecutor to run synchronous tasks concurrently
-    with ThreadPoolExecutor(max_workers=1) as executor:
-        # Create a future for each file processing task
-        loop = asyncio.get_event_loop()
-        tasks = [
-            loop.run_in_executor(
-                executor,
-                process_single_file,
-                file_path,
-                grader,
-                example_paper_text
-            )
-            for file_path in file_paths
-        ]
-
-        results = []
-        # Process results as they are completed
-        for i, future in enumerate(asyncio.as_completed(tasks)):
-            progress(i + 1, desc=f"Grading paper {i+1}/{total_files}...")
-            result = await future
-            results.append(result)
-
-    # --- Format the final output ---
-    successful_grades = [res for res in results if res.success]
-    failed_grades = [res for res in results if not res.success]
-
-    output_markdown = ""
-    for result in successful_grades:
-        output_markdown += f"### ✅ Grade for: **{result.file_name}**\n"
-        output_markdown += f"**Final Grade:** {result.grade}/100\n\n"
-
-        # Format point deductions
-        deductions_str = ""
-        for category, points in result.deductions.items():
-            if points > 0:
-                deductions_str += f"- **{category}:** Lost {points} points. *Reason: {result.feedback.get(category, 'N/A')}*\n"
-        if not deductions_str:
-            deductions_str = "Excellent work! No points were deducted.\n"
-
-        output_markdown += "**Point Deductions Breakdown:**\n" + deductions_str + "\n"
-        output_markdown += f"**Summary:** {result.summary}\n"
-        output_markdown += "---\n"
-
-    if failed_grades:
-        output_markdown += "### ❌ Failed Papers\n"
-        for result in failed_grades:
-            output_markdown += f"- **File:** {result.file_name}\n"
-            output_markdown += f"  - **Error:** {result.error_message}\n"
-        output_markdown += "---\n"
-
-    end_time = time.time()
-    runtime = f"Total runtime: {end_time - start_time:.2f} seconds."
-
-    status = (
-        f"Grading complete. {len(successful_grades)} papers graded successfully, "
-        f"{len(failed_grades)} failed."
-    )
-
-    return output_markdown, f"{status}\n{runtime}"
 
+        # Upload the example paper ONCE if it exists
+        if example_paper_file:
+            progress(0, desc="Uploading example paper...")
+            example_paper_file_obj = genai.upload_file(path=example_paper_file.name, display_name=os.path.basename(example_paper_file.name))
+            
+        file_paths = [file.name for file in files]
+        total_files = len(file_paths)
+
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            loop = asyncio.get_event_loop()
+            tasks = [
+                loop.run_in_executor(
+                    executor,
+                    process_single_file,
+                    file_path,
+                    grader,
+                    example_paper_file_obj
+                )
+                for file_path in file_paths
+            ]
 
-def process_single_file(file_path: str, grader: GeminiGrader, example_paper_text: str) -> GradingResult:
-    """
-    Synchronous wrapper function to parse and grade one file.
-    This function is what runs in each thread of the ThreadPoolExecutor.
-    """
-    file_name = os.path.basename(file_path)
-    try:
-        essay_text = EssayParser.parse_docx(file_path)
-        if not essay_text.strip():
-            return GradingResult(
-                file_name=file_name,
-                success=False,
-                error_message="The document is empty or contains no readable text."
-            )
-        return grader.grade_essay(essay_text, file_name, example_paper_text)
-    except Exception as e:
-        return GradingResult(file_name=file_name, success=False, error_message=str(e))
+            results = []
+            for i, future in enumerate(asyncio.as_completed(tasks)):
+                progress(i + 1, desc=f"Grading paper {i+1}/{total_files}...")
+                result = await future
+                results.append(result)
+
+        # --- Format the final output ---
+        successful_grades = [res for res in results if res.success]
+        failed_grades = [res for res in results if not res.success]
+        output_markdown = ""
+        for result in successful_grades:
+            output_markdown += f"### ✅ Grade for: **{result.file_name}**\n"
+            output_markdown += f"**Final Grade:** {result.grade}/100\n\n"
+            deductions_str = ""
+            for category, points in result.deductions.items():
+                if points > 0:
+                    deductions_str += f"- **{category}:** Lost {points} points. *Reason: {result.feedback.get(category, 'N/A')}*\n"
+            if not deductions_str:
+                deductions_str = "Excellent work! No points were deducted.\n"
+            output_markdown += "**Point Deductions Breakdown:**\n" + deductions_str + "\n"
+            output_markdown += f"**Summary:** {result.summary}\n"
+            output_markdown += "---\n"
+        if failed_grades:
+            output_markdown += "### ❌ Failed Papers\n"
+            for result in failed_grades:
+                output_markdown += f"- **File:** {result.file_name}\n"
+                output_markdown += f"  - **Error:** {result.error_message}\n"
+            output_markdown += "---\n"
+
+        end_time = time.time()
+        runtime = f"Total runtime: {end_time - start_time:.2f} seconds."
+        status = f"Grading complete. {len(successful_grades)} papers graded successfully, {len(failed_grades)} failed."
+        return output_markdown, f"{status}\n{runtime}"
+
+    finally:
+        # Clean up the uploaded example paper file at the very end
+        if example_paper_file_obj:
+            genai.delete_file(example_paper_file_obj.name)
 
 
 # --- Build the Gradio Interface ---
-
 with gr.Blocks(theme=gr.themes.Soft(), title="Nursing Essay Grader") as demo:
     gr.Markdown(
         """
         # 📝 Gemini-Powered Nursing Essay Grader
-        Upload one or more student essays in Word format (`.docx`) to have them graded by AI.
-        1.  Enter your Google API Key (enabling the Gemini API in your Google Cloud project is required).
-        2.  Upload the `.docx` files you want to grade.
-        3.  Optionally, upload a single `.pdf` file as a "perfect" example for the AI to reference.
-        4.  Click "Grade All Papers". The results will appear below.
+        Upload one or more student essays to have them graded by AI.
+        1.  Enter your Google API Key.
+        2.  Upload the `.docx` or `.pdf` files you want to grade.
+        3.  Optionally, upload a single `.docx` or `.pdf` file as a "perfect" example.
+        4.  Click "Grade All Papers".
         """
     )
-    with gr.Row():
-        api_key_input = gr.Textbox(
-            label="Google API Key",
-            placeholder="Enter your Google API Key here",
-            type="password",
-            scale=1
-        )
+    api_key_input = gr.Textbox(label="Google API Key", placeholder="Enter your Google API Key here", type="password")
+    
     with gr.Row():
         file_uploads = gr.File(
-            label="Upload Word Document Essays to Grade",
+            label="Upload Essays to Grade",
             file_count="multiple",
-            file_types=[".docx"],
+            file_types=['.pdf', '.docx'], # Allow both types
             type="filepath",
             scale=2
         )
         example_paper_upload = gr.File(
-            label="Upload Example PDF Paper (Optional)",
+            label="Upload Example Paper (Optional)",
             file_count="single",
-            file_types=[".pdf"],
+            file_types=['.pdf', '.docx'], # Allow both types
             type="filepath",
             scale=1
         )
@@ -421,11 +317,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Nursing Essay Grader") as demo:
     gr.Markdown("---")
     gr.Markdown("## 📊 Grading Results")
     results_output = gr.Markdown(label="Formatted Grades")
-    status_output = gr.Textbox(
-        label="Runtime Status",
-        lines=2,
-        interactive=False
-    )
+    status_output = gr.Textbox(label="Runtime Status", lines=2, interactive=False)
 
     grade_button.click(
         fn=grade_papers_concurrently,