Update app.py

app.py

@@ -8,8 +8,8 @@ from typing import List, Dict, Optional
 import os
 from pathlib import Path
 import time
-# The docx and fitz imports are no longer needed for the core logic
 
+# NOTE: No changes were made to your prompts or rubric.
 GRADING_RUBRIC = """
 GRADING RUBRIC (Total 100 points)
 
@@ -81,7 +81,6 @@ 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.
 
@@ -131,34 +130,28 @@ class GradingResult:
     summary: Optional[str] = None
     error_message: Optional[str] = None
 
-# --- Core Logic Classes ---
-# 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)
-            self.model = genai.GenerativeModel(model_name="gemini-1.5-pro-latest")
-        except Exception as e:
-            raise ValueError(f"Failed to configure Gemini API: {e}")
+        print("[DEBUG] Initializing GeminiGrader...")
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel(model_name="gemini-1.5-pro-latest")
+        print("[DEBUG] GeminiGrader initialized successfully.")
 
     def grade_essay(self, student_paper_file: object, example_paper_file: Optional[object]) -> GradingResult:
-        """
-        Sends files to Gemini for grading and parses the JSON response.
-        This method now takes API file objects directly.
-        """
+        """Sends files to Gemini for grading and parses the JSON response."""
+        print(f"[DEBUG] Inside grade_essay for student paper: {student_paper_file.display_name}")
         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:
+            print(f"[DEBUG] Example paper '{example_paper_file.display_name}' is being used.")
             content_list.append(example_paper_file)
         
         try:
-            response = self.model.generate_content(content_list)
+            print(f"[DEBUG] >>> Calling the Gemini model for grading... THIS IS THE LONG WAIT. <<<")
+            response = self.model.generate_content(content_list, request_options={'timeout': 600}) # 10 minute timeout
+            print(f"[DEBUG] <<< Model response received for {student_paper_file.display_name}. Parsing JSON.")
             cleaned_response = response.text.strip().replace("```json", "").replace("```", "")
             data = json.loads(cleaned_response)
 
@@ -166,6 +159,7 @@ class GeminiGrader:
             if not all(key in data for key in required_keys):
                 raise KeyError("Model response missing required keys.")
 
+            print(f"[DEBUG] Successfully parsed response for {student_paper_file.display_name}.")
             return GradingResult(
                 file_name=student_paper_file.display_name,
                 success=True,
@@ -174,44 +168,39 @@ class GeminiGrader:
                 feedback=data["feedback"],
                 summary=data["summary"]
             )
-        except json.JSONDecodeError:
-            return GradingResult(
-                file_name=student_paper_file.display_name,
-                success=False,
-                error_message="Failed to parse the model's JSON response."
-            )
         except Exception as e:
+            print(f"[DEBUG] !!! An error occurred in grade_essay: {e}")
             return GradingResult(
                 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.
-    """
+    """Uploads a single student paper and calls the grader."""
+    file_name = os.path.basename(file_path)
+    print(f"[DEBUG] Starting process_single_file for: {file_name}")
     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))
+        print(f"[DEBUG]   -> Uploading student paper '{file_name}' to Gemini Files API...")
+        student_paper_file_obj = genai.upload_file(path=file_path, display_name=file_name)
+        print(f"[DEBUG]   -> Upload successful for '{file_name}'. Handing off to grade_essay.")
         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))
+        print(f"[DEBUG] !!! An error occurred in process_single_file for '{file_name}': {e}")
+        return GradingResult(file_name=file_name, success=False, error_message=str(e))
     finally:
-        # Clean up the uploaded student paper file after processing
         if student_paper_file_obj:
+            print(f"[DEBUG]   -> Cleaning up uploaded file: {student_paper_file_obj.name}")
             genai.delete_file(student_paper_file_obj.name)
+            print(f"[DEBUG]   -> Cleanup complete for {file_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.
-    """
+    """The main asynchronous function that orchestrates the grading process."""
+    print("\n" + "="*50)
+    print("[DEBUG] grade_papers_concurrently initiated.")
     start_time = time.time()
     if not api_key:
         raise gr.Error("Google API Key is required.")
@@ -222,15 +211,18 @@ async def grade_papers_concurrently(
     try:
         grader = GeminiGrader(api_key)
 
-        # Upload the example paper ONCE if it exists
         if example_paper_file:
+            print("[DEBUG] Example paper provided. Uploading it now...")
             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))
+            print(f"[DEBUG] Example paper uploaded successfully: {example_paper_file_obj.name}")
             
         file_paths = [file.name for file in files]
         total_files = len(file_paths)
+        print(f"[DEBUG] Preparing to grade {total_files} paper(s).")
 
         with ThreadPoolExecutor(max_workers=1) as executor:
+            print("[DEBUG] ThreadPoolExecutor started (max_workers=1).")
             loop = asyncio.get_event_loop()
             tasks = [
                 loop.run_in_executor(
@@ -244,11 +236,13 @@ async def grade_papers_concurrently(
             ]
 
             results = []
+            print("[DEBUG] Waiting for grading tasks to complete...")
             for i, future in enumerate(asyncio.as_completed(tasks)):
-                progress(i + 1, desc=f"Grading paper {i+1}/{total_files}...")
                 result = await future
+                print(f"[DEBUG] Task {i+1}/{total_files} completed for file: {result.file_name}")
                 results.append(result)
 
+        print("[DEBUG] All grading tasks finished. Formatting final output.")
         # --- 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]
@@ -275,13 +269,15 @@ async def grade_papers_concurrently(
         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."
+        print(f"[DEBUG] Process finished. {runtime}")
+        print("="*50 + "\n")
         return output_markdown, f"{status}\n{runtime}"
 
     finally:
-        # Clean up the uploaded example paper file at the very end
         if example_paper_file_obj:
+            print("[DEBUG] Final cleanup: Deleting example paper from API.")
             genai.delete_file(example_paper_file_obj.name)
-
+            print("[DEBUG] Final cleanup complete.")
 
 # --- Build the Gradio Interface ---
 with gr.Blocks(theme=gr.themes.Soft(), title="Nursing Essay Grader") as demo:
@@ -301,14 +297,14 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Nursing Essay Grader") as demo:
         file_uploads = gr.File(
             label="Upload Essays to Grade",
             file_count="multiple",
-            file_types=['.pdf', '.docx'], # Allow both types
+            file_types=['.pdf', '.docx'],
             type="filepath",
             scale=2
         )
         example_paper_upload = gr.File(
             label="Upload Example Paper (Optional)",
             file_count="single",
-            file_types=['.pdf', '.docx'], # Allow both types
+            file_types=['.pdf', '.docx'],
             type="filepath",
             scale=1
         )