Refactor: Generalize benchmark for JEE and NEET exams

- Update parsing, LLM prompts, and evaluation for various question types (MCQ Single/Multiple, Integer).
- Implement specific scoring rules for NEET, JEE Main, and JEE Advanced.
- Make benchmark runner and README more generic to support multiple exams.

README.md

@@ -17,10 +17,11 @@ task_categories:
   - visual-question-answering
   - image-text-to-text
   - question-answering
+  - multimodal-reasoning
 # task_ids: # More specific task IDs from https://hf.co/tasks
 #   - visual-question-answering
 # Pretty name for the dataset.
-pretty_name: JEE/NEET LLM Benchmark
+pretty_name: Indian Competitive Exams (JEE/NEET) LLM Benchmark
 # Dataset identifier from a recognized benchmark.
 # benchmark: # e.g., super_glue, anli
 # Date of the last update.
@@ -70,19 +71,20 @@ column_info:
     description: Subject (e.g., "Physics", "Chemistry", "Biology", "Mathematics").
     data_type: string
   question_type:
-    description: Type of question (e.g., "MCQ", "Multiple Correct").
+    description: Type of question (e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER").
     data_type: string
   correct_answer:
-    description: List containing the correct answer index/indices (e.g., [2], [1, 3]).
+    description: List containing the correct answer index/indices (e.g., [2], [1, 3]) or a single integer for INTEGER type.
     data_type: list[int32] # or sequence of int32
 
 # More Information
 # ----------------
 # Add any other relevant information about the dataset.
 dataset_summary: |
-  A benchmark dataset for evaluating Large Language Models (LLMs) on Joint Entrance Examination (JEE)
-  and National Eligibility cum Entrance Test (NEET) questions from India. Questions are provided as
-  images, and metadata includes exam details, subject, and correct answers.
+  A benchmark dataset for evaluating Large Language Models (LLMs) on questions from major Indian competitive examinations:
+  Joint Entrance Examination (JEE Main & Advanced) for engineering and the National Eligibility cum Entrance Test (NEET) for medical fields.
+  Questions are provided as images, and metadata includes exam details (name, year, subject, question type) and correct answers.
+  The benchmark supports various question types including Single Correct MCQs, Multiple Correct MCQs (with partial marking for JEE Advanced), and Integer type questions.
 dataset_tags: # Tags to help users find your dataset
   - education
   - science
@@ -117,12 +119,16 @@ personal_sensitive_information: false # Does the dataset contain PII?
 
 ## Dataset Description
 
-This repository contains a benchmark dataset designed for evaluating the capabilities of Large Language Models (LLMs) on questions from the Joint Entrance Examination (JEE) and the National Eligibility cum Entrance Test (NEET) conducted in India. These are highly competitive entrance examinations for engineering and medical colleges, respectively.
+This repository contains a benchmark dataset designed for evaluating the capabilities of Large Language Models (LLMs) on questions from major Indian competitive examinations:
+*   **JEE (Main & Advanced):** Joint Entrance Examination for engineering.
+*   **NEET:** National Eligibility cum Entrance Test for medical fields.
 
-The questions are presented in image format (`.png`) as they appear in the original papers. The dataset includes metadata linking each image to its corresponding exam details, subject, question type, and correct answer(s).
+The questions are presented in image format (`.png`) as they appear in the original papers. The dataset includes metadata linking each image to its corresponding exam details (name, year, subject, question type), and correct answer(s). The benchmark framework supports various question types including Single Correct MCQs, Multiple Correct MCQs (with partial marking for JEE Advanced), and Integer type questions.
 
-**Current Data:**
+**Current Data (Examples):**
 *   NEET 2024 (Code T3)
+*   NEET 2025 (Code 45)
+*   (Support for JEE Main & Advanced questions can be added by updating `data/metadata.jsonl` and the `images/` directory accordingly.)
 
 ## How to Use
 
@@ -178,7 +184,7 @@ This repository contains scripts to run the benchmark evaluation directly:
     *   **Important:** The `.gitignore` file is already configured to prevent committing the `.env` file. Never commit your API keys directly.
 4.  **Configure Models:**
     *   Edit the `configs/benchmark_config.yaml` file.
-    *   Modify the `openrouter_models` list to include the specific model identifiers (e.g., `"openai/gpt-4o"`, `"google/gemini-pro-vision"`) you want to evaluate. Ensure these models support vision input on OpenRouter.
+    *   Modify the `openrouter_models` list to include the specific model identifiers (e.g., `"openai/gpt-4o"`, `"google/gemini-2.5-pro-preview-03-25"`) you want to evaluate. Ensure these models support vision input on OpenRouter.
     *   You can also adjust other parameters like `max_tokens` and `request_timeout` if needed.
 5.  **Run the benchmark:**
     *   Execute the runner script from the root directory:
@@ -193,37 +199,40 @@ This repository contains scripts to run the benchmark evaluation directly:
         ```bash
         python src/benchmark_runner.py --config configs/benchmark_config.yaml --output_dir my_custom_results
         ```
-    *   To run the benchmark on a specific exam paper, use the `--exam_name` and `--exam_year` arguments. Both must be provided:
+    *   To run the benchmark on a specific exam paper, use the `--exam_name` and `--exam_year` arguments. Both must be provided. The `exam_name` should match the values in your `metadata.jsonl` (e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED").
         ```bash
         # Example: Run only NEET 2024 questions
         python src/benchmark_runner.py --config configs/benchmark_config.yaml --exam_name NEET --exam_year 2024
         
-        # Example: Run only NEET 2025 questions (assuming data exists)
-        python src/benchmark_runner.py --config configs/benchmark_config.yaml --exam_name NEET --exam_year 2025 
+        # Example: Run only JEE_MAIN 2023 questions (assuming data exists)
+        python src/benchmark_runner.py --config configs/benchmark_config.yaml --exam_name JEE_MAIN --exam_year 2023
         ```
-        Note: If using exam names with spaces, enclose them in quotes.
+        Note: If using exam names with spaces (though not recommended in metadata), enclose them in quotes.
 6.  **Check Results:**
     *   Results for each model will be saved in subdirectories within the `results/` folder (or your custom output directory).
-    *   Each model's folder (e.g., `results/provider/modelname_YYYYMMDD_HHMMSS`) will contain:
-        *   `predictions.jsonl`: Detailed results for each question (prediction, ground truth, raw response).
-        *   `summary.json`: Overall accuracy and statistics for that model.
-    *   Sample benchmark results for some models can be found in the `results/` folder.
+    *   Each model's folder (e.g., `results/openai_gpt-4o_NEET_2024_YYYYMMDD_HHMMSS`) will contain:
+        *   `predictions.jsonl`: Detailed results for each question (prediction, ground truth, raw response, evaluation status, marks awarded).
+        *   `summary.json`: Overall scores and statistics for that model run.
+        *   `summary.md`: A human-readable Markdown version of the summary.
+    *   Sample benchmark results for some models can be found in the `results/` folder (these may be outdated).
 
 ## Pros
 
 *   **Multimodal Reasoning:** Uses images of questions directly, testing the multimodal reasoning capability of the model.
-*   **Reattempt Mechanism:** Implements a reattempt mechanism to encourage the model to provide the final answer within `<answer>` tags.
+*   **Flexible Exam Support:** Designed to support multiple exams (NEET, JEE Main, JEE Advanced) and various question types (MCQ Single Correct, MCQ Multiple Correct, Integer).
+*   **Detailed Scoring:** Implements specific scoring rules for different exams and question types, including partial marking for JEE Advanced multiple correct questions.
+*   **Reattempt Mechanism:** Implements a reattempt mechanism to encourage the model to provide the final answer within `<answer>` tags, adapted for different question types.
 *   **Reproducibility:** Easily reproducible with simple commands and an OpenRouter API key.
 *   **Model Flexibility:** Allows testing of various models available through OpenRouter.
 
 ## Dataset Structure
 
-*   **`data/metadata.jsonl`**: Contains metadata for each question image. Each line is a JSON object with fields like `image_path`, `question_id`, `exam_name`, `exam_year`, `exam_code`, `subject`, `question_type`, `correct_answer`.
-*   **`images/`**: Contains subdirectories for each exam set (e.g., `images/NEET_2024_T3/`), holding the `.png` question images.
+*   **`data/metadata.jsonl`**: Contains metadata for each question image. Each line is a JSON object with fields like `image_path`, `question_id`, `exam_name` (e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED"), `exam_year`, `subject`, `question_type` (e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER"), `correct_answer`.
+*   **`images/`**: Contains subdirectories for each exam set (e.g., `images/NEET_2024_T3/`, `images/JEE_MAIN_2023_Example/`), holding the `.png` question images.
 *   **`src/`**: Python source code for running the benchmark (data loading, LLM interaction, evaluation).
 *   **`configs/`**: Configuration files for the benchmark.
 *   **`results/`**: Directory where benchmark results (LLM outputs) will be stored.
-*   **`jee_neet_benchmark_dataset.py`**: Hugging Face `datasets` loading script.
+*   **`jee_neet_benchmark_dataset.py`**: Hugging Face `datasets` loading script (defines how to load `metadata.jsonl` and images).
 *   **`requirements.txt`**: Python dependencies.
 *   **`README.md`**: This file.
 
@@ -233,17 +242,16 @@ The dataset contains the following fields (accessible via `datasets`):
 
 *   `image`: The question image (`datasets.Image`).
 *   `question_id`: Unique identifier for the question (string).
-*   `exam_name`: Name of the exam (e.g., "NEET", "JEE Main") (string).
+*   `exam_name`: Name of the exam (e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED") (string).
 *   `exam_year`: Year of the exam (int).
-*   `exam_code`: Specific paper code/session (e.g., "T3", "S1") (string).
-*   `subject`: Subject (e.g., "Physics", "Chemistry", "Biology", "Mathematics") (string).
-*   `question_type`: Type of question (e.g., "MCQ", "Multiple Correct") (string).
-*   `correct_answer`: List containing the correct answer index/indices (e.g., `[2]`, `[1, 3]`) (list of int).
+*   `subject`: Subject (e.g., "Physics", "Chemistry", "Botany", "Zoology", "Mathematics") (string).
+*   `question_type`: Type of question (e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER") (string).
+*   `correct_answer`: List containing the correct answer index/indices (e.g., `[2]`, `[1, 3]`) or a single integer for INTEGER type questions (list of int, or int).
 
 ## Cons / Current Limitations
 
-*   **Early Development:** The benchmark is still in its early stages of development.
-*   **Limited Data:** Currently, only one exam question paper (NEET 2024 T3) is available. More exam papers are planned for future inclusion.
+*   **Data Expansion:** While the framework supports various exams and question types, the current `metadata.jsonl` primarily contains NEET data. More diverse data (especially for JEE Main and Advanced with varied question types) needs to be added to make the benchmark more comprehensive.
+*   **Max Score in Summary:** The overall maximum score in the generated Markdown summary is currently marked as "N/A (variable per question)" due to the complexity of calculating it accurately across mixed question types in a single run. Each question's max score depends on its type and exam.
 
 ## Citation
 

src/benchmark_runner.py

@@ -12,8 +12,8 @@ from PIL import Image as PILImage # Import PIL for type hinting
 # Import local modules
 from utils import load_api_key
 from llm_interface import get_openrouter_prediction
-# Import both evaluation functions
-from evaluation import calculate_accuracy, calculate_neet_scores
+# Import evaluation functions
+from evaluation import calculate_accuracy, calculate_exam_scores
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -76,63 +76,68 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
         md_content.append("\n---\n")
 
         # Check if NEET results are present (or any dataset with overall_score and section_breakdown)
-        if "overall_score" in summary and "section_breakdown" in summary:
+        if "overall_score" in summary and "section_breakdown" in summary: # Generic check for score-based summary
             total_processed = summary.get("total_questions_processed", 0)
-            # Dynamically calculate max_score based on questions in the dataset used for this run
-            max_score = total_questions_in_dataset * 4 if total_questions_in_dataset > 0 else "N/A"
+            
+            # Max score calculation is complex due to varied scoring per question.
+            # For now, we'll omit max_score from the overall display or acknowledge its variability.
+            # A more accurate max_score would require iterating through the dataset items used in the run
+            # and summing their individual max possible scores based on exam_name and question_type.
+            # This is out of scope for the current summary generation simplicity.
+            max_score_display = "N/A (variable per question)" # Placeholder
+
             overall_score = summary.get('overall_score', 'N/A')
-            correct_count = summary.get('overall_correct', 'N/A')
-            incorrect_count = summary.get('overall_incorrect', 'N/A')
+            correct_full_count = summary.get('overall_correct_full', 'N/A')
+            partial_correct_count = summary.get('overall_partial_correct', 'N/A')
+            incorrect_choice_count = summary.get('overall_incorrect_choice', 'N/A')
             skipped_count = summary.get('overall_skipped', 'N/A')
             failures_count = summary.get('overall_api_parse_failures', 'N/A')
             unmapped_count = summary.get('unmapped_section_questions', 'N/A')
 
-            md_content.append("## NEET Scoring Results")
-            md_content.append(f"**Overall Score:** **{overall_score} / {max_score}**")
-            md_content.append(f"- **Correct Answers (+4):** {correct_count}")
-            md_content.append(f"- **Incorrect Answers (-1):** {incorrect_count}")
-            md_content.append(f"- **Skipped Questions (0):** {skipped_count}")
-            md_content.append(f"- **API/Parse Failures (-1):** {failures_count}")
+            md_content.append("## Exam Scoring Results") # Changed from NEET
+            md_content.append(f"**Overall Score:** **{overall_score}** (Max score varies based on question types)")
+            md_content.append(f"- **Fully Correct Answers:** {correct_full_count}")
+            if partial_correct_count != 'N/A' and partial_correct_count > 0 : # Only show if applicable
+                md_content.append(f"- **Partially Correct Answers:** {partial_correct_count}")
+            md_content.append(f"- **Incorrectly Answered (Choice Made):** {incorrect_choice_count}")
+            md_content.append(f"- **Skipped Questions:** {skipped_count}")
+            md_content.append(f"- **API/Parse Failures:** {failures_count}")
             md_content.append(f"- **Total Questions Processed:** {total_processed}")
             if unmapped_count > 0:
-                md_content.append(f"- **Unmapped Section Questions:** {unmapped_count} *(These were not included in section breakdown)*")
+                md_content.append(f"- **Unmapped Section Questions:** {unmapped_count} *(Not included in section breakdown)*")
 
             md_content.append("\n### Section Breakdown")
-            md_content.append("| Section       | Score | Correct | Incorrect | Skipped |")
-            md_content.append("|---------------|-------|---------|-----------|---------|")
+            md_content.append("| Section       | Score | Fully Correct | Partially Correct | Incorrect Choice | Skipped | API/Parse Failures |")
+            md_content.append("|---------------|-------|---------------|-------------------|------------------|---------|--------------------|")
             section_breakdown = summary.get("section_breakdown", {})
             
-            # Dynamically get section names (subjects) from the breakdown, sorted for consistent order
             sorted_section_names = sorted(section_breakdown.keys())
-            if not sorted_section_names and section_breakdown: # If keys exist but sorting failed (e.g. mixed types)
+            if not sorted_section_names and section_breakdown:
                 logging.warning("Could not sort section names for Markdown summary; using unsorted.")
                 sorted_section_names = list(section_breakdown.keys())
 
             for section_name in sorted_section_names:
-                stats = section_breakdown.get(section_name, {}) # Should always find it
+                stats = section_breakdown.get(section_name, {})
                 score = stats.get('score', 'N/A')
-                correct = stats.get('correct', 'N/A')
-                incorrect = stats.get('incorrect', 'N/A')
-                skipped = stats.get('skipped', 'N/A')
-                display_section_name = section_name.replace('_', ' ') # Basic formatting
-                md_content.append(f"| {display_section_name:<13} | {score:<5} | {correct:<7} | {incorrect:<9} | {skipped:<7} |")
+                s_correct = stats.get('correct', 'N/A') # This is full correct from new structure
+                s_partial = stats.get('partial_correct', 'N/A')
+                s_incorrect = stats.get('incorrect', 'N/A') # This is incorrect choice from new structure
+                s_skipped = stats.get('skipped', 'N/A')
+                s_failures = stats.get('api_parse_failures', 'N/A')
+                display_section_name = section_name.replace('_', ' ')
+                md_content.append(f"| {display_section_name:<13} | {score:<5} | {s_correct:<13} | {s_partial:<17} | {s_incorrect:<16} | {s_skipped:<7} | {s_failures:<18} |")
             if not sorted_section_names:
-                md_content.append("| No section data available | N/A   | N/A     | N/A       | N/A     |")
-
-
-        # Fallback or alternative for simple accuracy
-        elif "accuracy_on_parsed" in summary:
-            md_content.append("## Simple Accuracy Results")
+                md_content.append("| No section data available | N/A   | N/A           | N/A               | N/A              | N/A     | N/A                |")
+        
+        # Fallback for simple accuracy (if exam scoring wasn't applicable or failed)
+        elif "accuracy_on_parsed" in summary: # This branch might be less used if all datasets now have exam_name/type
+            md_content.append("## Simple Accuracy Results (Fallback)")
             md_content.append(f"- **Accuracy (on successfully parsed non-skipped):** {summary.get('accuracy_on_parsed', 'N/A'):.4f}")
             md_content.append(f"- **Total Processed Attempts:** {summary.get('total_processed_attempts', 'N/A')}")
-            md_content.append(f"- **Successful API Calls:** {summary.get('successful_api_calls', 'N/A')}")
-            md_content.append(f"- **Successful Parses:** {summary.get('successful_parses', 'N/A')}")
+            # Add other relevant simple stats if available
         else:
             md_content.append("## Summary")
-            md_content.append("*(No specific NEET or Accuracy metrics found in summary)*")
-            # Optionally print raw summary keys/values
-            # for key, value in summary.items():
-            #     md_content.append(f"- **{key}:** {value}")
+            md_content.append("*(No specific Exam Scoring or Accuracy metrics found in summary)*")
 
 
         with open(filepath, 'w') as f:
@@ -230,308 +235,213 @@ def run_benchmark(config: dict, api_key: str, models_override: list[str] | None
         # --- Initial Pass: Iterate through questions ---
         for example in tqdm(dataset, desc=f"Processing {model_id} (Initial Pass)", total=total_questions):
             question_id = example["question_id"]
-            subject = example["subject"] # Get subject for evaluation
+            subject = example["subject"]
+            exam_name_from_data = example.get("exam_name", "UNKNOWN_EXAM") # Get exam_name from data
+            question_type_from_data = example.get("question_type", "MCQ_SINGLE_CORRECT") # Get question_type
             image: PILImage.Image = example["image"]
             truth = example["correct_answer"]
 
             result_data = {
                 "question_id": question_id,
                 "subject": subject,
+                "exam_name": exam_name_from_data, # Store for evaluation
+                "question_type": question_type_from_data, # Store for evaluation
                 "ground_truth": truth,
                 "predicted_answer": None,
                 "raw_response": None,
                 "parse_successful": False,
-                "api_call_successful": False, # Assume failure initially
+                "api_call_successful": False,
                 "error": None,
-                "attempt": 1 # Mark as first attempt
+                "attempt": 1 
             }
 
             try:
                 # --- Initial API Call ---
+                # Pass exam_name_from_data and question_type_from_data to get_openrouter_prediction
                 parsed_answer, raw_response = get_openrouter_prediction(
                     model_identifier=model_id,
                     api_key=api_key,
-                    image=image, # Pass image for initial call
-                    exam_name=exam_name_filter, # Pass exam_name
-                    exam_year=exam_year_filter, # Pass exam_year
+                    image=image,
+                    exam_name=exam_name_from_data, # Use exam_name from current data item
+                    exam_year=str(example.get("exam_year", "UNKNOWN_YEAR")), # Use exam_year from data
+                    question_type=question_type_from_data, # Pass question_type
                     max_tokens=config.get("max_tokens", 100),
-                     request_timeout=config.get("request_timeout", 60)
-                 )
-
-                # Initial attempt results
-                api_success_attempt1 = True
-                parse_success_attempt1 = parsed_answer is not None # Includes SKIP
+                    request_timeout=config.get("request_timeout", 60)
+                )
+                
+                api_success_attempt1 = True # If no exception, API call itself was successful
+                parse_success_attempt1 = parsed_answer is not None
                 raw_response_attempt1 = raw_response
 
                 # --- Re-prompt Logic ---
                 if api_success_attempt1 and not parse_success_attempt1 and raw_response_attempt1 is not None:
                     logging.warning(f"Question {question_id}: Initial parse failed. Attempting re-prompt.")
                     try:
-                        # Second API call (re-prompt)
                         parsed_answer_rp, raw_response_rp = get_openrouter_prediction(
                             model_identifier=model_id,
                             api_key=api_key,
-                            previous_raw_response=raw_response_attempt1, # Pass previous response
+                            previous_raw_response=raw_response_attempt1,
+                            question_type=question_type_from_data, # Pass question_type for re-prompt
                             max_tokens=config.get("max_tokens", 100),
                             request_timeout=config.get("request_timeout", 60)
                         )
-                        # Update results with re-prompt outcome
                         result_data.update({
                             "predicted_answer": parsed_answer_rp,
-                            "raw_response": raw_response_rp, # Store the re-prompt response
-                            "parse_successful": parsed_answer_rp is not None, # Includes SKIP
-                            "api_call_successful": True, # API call was successful
-                            "attempt": 2 # Mark as second attempt due to re-prompt
+                            "raw_response": raw_response_rp,
+                            "parse_successful": parsed_answer_rp is not None,
+                            "api_call_successful": True, 
+                            "attempt": 2
                         })
                         logging.info(f"Question {question_id}: Re-prompt {'succeeded' if result_data['parse_successful'] else 'failed to parse'}.")
-
                     except Exception as e_rp:
-                        # Handle failure during the re-prompt API call itself
                         logging.error(f"Re-prompt API call failed for question {question_id}: {e_rp}")
-                        # Keep initial attempt data, but mark as failed parse and add re-prompt error
                         result_data.update({
-                            "predicted_answer": None, # Failed parse overall
-                            "raw_response": raw_response_attempt1, # Keep original raw response
+                            "predicted_answer": None, 
+                            "raw_response": raw_response_attempt1, 
                             "parse_successful": False,
-                            "api_call_successful": True, # Initial API call succeeded
+                            "api_call_successful": True, 
                             "error": f"Initial parse failed. Re-prompt API call failed: {str(e_rp)}",
-                            "attempt": 1 # Revert attempt count as re-prompt failed
+                            "attempt": 1 
                         })
                 else:
-                    # Initial API call was successful and parsed correctly, or API failed initially,
-                    # or re-prompt was skipped due to empty initial response.
-                    current_error = result_data.get("error") # Preserve existing error if any from re-prompt failure
+                    current_error = result_data.get("error") 
                     api_actually_successful = api_success_attempt1
-
                     if api_success_attempt1 and raw_response_attempt1 is None and parsed_answer is None:
-                        # This case specifically handles when initial call was "successful" (no exception)
-                        # but returned no content, and thus re-prompt was skipped.
                         current_error = "Initial API call returned empty content. Re-prompt skipped."
-                        # Consider if api_call_successful should be False for scoring if empty means failure
-                        # For now, we keep it as True if no exception occurred during the API call itself.
-
+                    
                     result_data.update({
                         "predicted_answer": parsed_answer,
                         "raw_response": raw_response_attempt1,
-                        "parse_successful": parse_success_attempt1, # This would be False if parsed_answer is None
+                        "parse_successful": parse_success_attempt1,
                         "api_call_successful": api_actually_successful,
                         "error": current_error,
-                        "attempt": 1 # Remains attempt 1 if re-prompt didn't occur or failed
+                        "attempt": 1 
                     })
-
-                # Append final result (from initial success or re-prompt attempt)
+                
                 model_results.append(result_data)
                 append_prediction(result_data, predictions_path)
 
-                # Provide live feedback based on final result_data
                 final_parsed_answer = result_data["predicted_answer"]
                 if result_data["parse_successful"]:
                     if final_parsed_answer == "SKIP":
                         logging.info(f"Question {question_id}: Skipped (Attempt {result_data['attempt']})")
-                    else:
-                        is_correct = isinstance(final_parsed_answer, list) and sorted(final_parsed_answer) == sorted(truth)
-                        logging.info(f"Question {question_id}: {'Correct' if is_correct else 'Incorrect'} (Attempt {result_data['attempt']})")
-                else: # Parse failed even after potential re-prompt
+                    else: # For logging, simple truth comparison
+                        is_correct_log = isinstance(final_parsed_answer, list) and sorted(final_parsed_answer) == sorted(truth if isinstance(truth, list) else [truth])
+                        logging.info(f"Question {question_id}: {'Correct (log)' if is_correct_log else 'Incorrect (log)'} (Attempt {result_data['attempt']})")
+                else:
                      logging.info(f"Question {question_id}: Failed to parse answer (Attempt {result_data['attempt']})")
 
-
             except Exception as e:
-                # Catch potential failures from the *initial* get_openrouter_prediction call (after its internal retries)
                 logging.error(f"Initial API call failed for question {question_id} (Attempt 1): {e}")
                 result_data["error"] = str(e)
-                result_data["api_call_successful"] = False # Explicitly mark API failure
-                # Store data needed for the separate API retry pass
-                failed_questions_data.append(example) # Store original example data
-                # Do not append to model_results or predictions file yet for initial API failures
-
+                result_data["api_call_successful"] = False
+                failed_questions_data.append(example) # Store original example for retry pass
 
-        # --- Retry Pass: Iterate through questions where the *initial API call* failed ---
+        # --- Retry Pass for questions with initial API failures ---
         if failed_questions_data:
             logging.info(f"--- Retrying {len(failed_questions_data)} questions with initial API failures for model: {model_id} ---")
-            for example in tqdm(failed_questions_data, desc=f"Processing {model_id} (API Retry Pass)", total=len(failed_questions_data)):
-                question_id = example["question_id"]
-                subject = example["subject"]
-                image: PILImage.Image = example["image"]
-                truth = example["correct_answer"]
-
-                # Initialize result data for the API retry attempt
-                result_data = {
-                    "question_id": question_id,
-                    "subject": subject, # Get subject for evaluation
-                    "ground_truth": truth,
+            for example_retry in tqdm(failed_questions_data, desc=f"Processing {model_id} (API Retry Pass)", total=len(failed_questions_data)):
+                question_id_retry = example_retry["question_id"]
+                subject_retry = example_retry["subject"]
+                exam_name_retry = example_retry.get("exam_name", "UNKNOWN_EXAM")
+                question_type_retry = example_retry.get("question_type", "MCQ_SINGLE_CORRECT")
+                image_retry: PILImage.Image = example_retry["image"]
+                truth_retry = example_retry["correct_answer"]
+
+                result_data_retry = {
+                    "question_id": question_id_retry,
+                    "subject": subject_retry,
+                    "exam_name": exam_name_retry,
+                    "question_type": question_type_retry,
+                    "ground_truth": truth_retry,
                     "predicted_answer": None,
                     "raw_response": None,
                     "parse_successful": False,
-                    "api_call_successful": False, # Assume failure initially
-                    "error": None,
-                    "attempt": 2 # Mark as second attempt (due to API retry)
+                    "api_call_successful": False,
+                    "error": "Initial API call failed.", # Pre-fill error
+                    "attempt": 2 
                 }
 
                 try:
-                    # Retry getting prediction (initial call logic again)
-                    parsed_answer, raw_response = get_openrouter_prediction(
+                    parsed_answer_retry, raw_response_retry = get_openrouter_prediction(
                         model_identifier=model_id,
                         api_key=api_key,
-                        image=image, # Pass image for this retry
-                        exam_name=exam_name_filter, # Pass exam_name
-                        exam_year=exam_year_filter, # Pass exam_year
+                        image=image_retry,
+                        exam_name=exam_name_retry,
+                        exam_year=str(example_retry.get("exam_year", "UNKNOWN_YEAR")),
+                        question_type=question_type_retry,
                         max_tokens=config.get("max_tokens", 100),
                         request_timeout=config.get("request_timeout", 60)
                     )
-                    # API Retry succeeded, now check parsing
                     api_success_attempt2 = True
-                    parse_success_attempt2 = parsed_answer is not None # Includes SKIP
-                    raw_response_attempt2 = raw_response
+                    parse_success_attempt2 = parsed_answer_retry is not None
+                    raw_response_attempt2 = raw_response_retry
 
-                    # --- Re-prompt Logic (within API Retry Pass) ---
                     if api_success_attempt2 and not parse_success_attempt2 and raw_response_attempt2 is not None:
-                        logging.warning(f"Question {question_id}: API Retry succeeded, but parse failed. Attempting re-prompt.")
+                        logging.warning(f"Question {question_id_retry}: API Retry succeeded, but parse failed. Attempting re-prompt.")
                         try:
-                            # Third API call (re-prompt after API retry)
                             parsed_answer_rp2, raw_response_rp2 = get_openrouter_prediction(
                                 model_identifier=model_id,
                                 api_key=api_key,
-                                previous_raw_response=raw_response_attempt2, # Pass API retry response
+                                previous_raw_response=raw_response_attempt2,
+                                question_type=question_type_retry,
                                 max_tokens=config.get("max_tokens", 100),
                                 request_timeout=config.get("request_timeout", 60)
                             )
-                            # Update results with re-prompt outcome
-                            result_data.update({
-                                "predicted_answer": parsed_answer_rp2,
-                                "raw_response": raw_response_rp2,
-                                "parse_successful": parsed_answer_rp2 is not None,
-                                "api_call_successful": True,
-                                "attempt": 3 # Mark as third attempt (API retry + re-prompt)
+                            result_data_retry.update({
+                                "predicted_answer": parsed_answer_rp2, "raw_response": raw_response_rp2,
+                                "parse_successful": parsed_answer_rp2 is not None, "api_call_successful": True,
+                                "error": None if parsed_answer_rp2 is not None else "Re-prompt after API retry failed to parse.",
+                                "attempt": 3
                             })
-                            logging.info(f"Question {question_id}: API Retry + Re-prompt {'succeeded' if result_data['parse_successful'] else 'failed to parse'}.")
-
+                            logging.info(f"Question {question_id_retry}: API Retry + Re-prompt {'succeeded' if result_data_retry['parse_successful'] else 'failed to parse'}.")
                         except Exception as e_rp2:
-                            # Handle failure during the re-prompt API call itself
-                            logging.error(f"Re-prompt API call failed for question {question_id} after API retry: {e_rp2}")
-                            result_data.update({
-                                "predicted_answer": None, # Failed parse overall
-                                "raw_response": raw_response_attempt2, # Keep API retry raw response
-                                "parse_successful": False,
-                                "api_call_successful": True, # API retry call succeeded
-                                "error": f"API retry succeeded, but parse failed. Re-prompt failed: {str(e_rp2)}",
-                                "attempt": 2 # Revert attempt count
+                            logging.error(f"Re-prompt API call failed for question {question_id_retry} after API retry: {e_rp2}")
+                            result_data_retry.update({
+                                "error": f"API retry ok, parse failed. Re-prompt API call failed: {str(e_rp2)}",
+                                "attempt": 2 # Stay at attempt 2 as re-prompt itself failed
                             })
                     else:
-                         # API retry succeeded and parsed correctly, or re-prompt was skipped.
-                        current_error_retry = result_data.get("error") # Preserve error from re-prompt failure
-                        api_actually_successful_retry = api_success_attempt2
-
-                        if api_success_attempt2 and raw_response_attempt2 is None and parsed_answer is None:
+                        current_error_retry = result_data_retry.get("error")
+                        if api_success_attempt2 and raw_response_attempt2 is None and parsed_answer_retry is None:
                             current_error_retry = "API retry call returned empty content. Re-prompt skipped."
-
-                        result_data.update({
-                            "predicted_answer": parsed_answer,
-                            "raw_response": raw_response_attempt2,
-                            "parse_successful": parse_success_attempt2, # False if parsed_answer is None
-                            "api_call_successful": api_actually_successful_retry,
-                            "error": current_error_retry,
-                            "attempt": 2 # Remains attempt 2 if re-prompt didn't occur or failed
+                        
+                        result_data_retry.update({
+                            "predicted_answer": parsed_answer_retry, "raw_response": raw_response_attempt2,
+                            "parse_successful": parse_success_attempt2, "api_call_successful": api_success_attempt2,
+                            "error": None if parse_success_attempt2 else current_error_retry, # Clear initial error if parse now ok
+                            "attempt": 2
                         })
-
-                except Exception as e:
-                    # Final API failure after the API retry pass
-                    logging.error(f"API call failed permanently for question {question_id} (Attempt 2 API Retry): {e}")
-                    result_data["error"] = str(e)
-                    result_data["api_call_successful"] = False # Remains False
-                    result_data["attempt"] = 2 # Still attempt 2
-
-                # Append the final result (success or failure) from the API retry pass (including potential re-prompt)
-                model_results.append(result_data)
-                append_prediction(result_data, predictions_path)
-
+                except Exception as e_retry_api:
+                    logging.error(f"API call failed permanently for question {question_id_retry} (Attempt 2 API Retry): {e_retry_api}")
+                    result_data_retry["error"] = f"Initial API fail. Retry API call also failed: {str(e_retry_api)}"
+                    result_data_retry["api_call_successful"] = False
+                
+                model_results.append(result_data_retry)
+                append_prediction(result_data_retry, predictions_path)
 
         # --- Final Evaluation for the current model ---
         logging.info(f"--- Calculating final results for model: {model_id} ---")
-
-        # Use the new NEET scoring function
-        # Check if the dataset is NEET before applying NEET scoring
-        # We infer this based on the presence of subjects like Botany/Zoology or question ID format
-        is_neet_dataset = any(res.get("subject") in ["Botany", "Zoology"] for res in model_results) or \
-                          (model_results and model_results[0].get("question_id", "").startswith("NEET"))
-
-        if is_neet_dataset:
-             logging.info("Detected NEET dataset. Applying NEET scoring.")
-             evaluation_summary = calculate_neet_scores(model_results) # model_results modified in-place
-             
-             # Determine exam name and year for summary
-             summary_exam_name = exam_name_filter if exam_name_filter else "All_Exams"
-             summary_exam_year = exam_year_filter if exam_year_filter else "All_Years"
-
-             summary = {
-                 "model_name": model_id,
-                 "exam_name": summary_exam_name,
-                 "exam_year": summary_exam_year,
-                 "timestamp": timestamp,
-                 "total_questions_in_dataset": total_questions, # This is total in dataset *before* model processing
-                 **evaluation_summary # Merge NEET score details (includes total_questions_processed)
-             }
-             logging.info(f"NEET Score: {summary.get('overall_score')}")
-             logging.info(f"Correct: {summary.get('overall_correct')}, Incorrect: {summary.get('overall_incorrect')}, Skipped: {summary.get('overall_skipped')}, API/Parse Failures: {summary.get('overall_api_parse_failures')}")
-
-        else:
-             # Fallback to simple accuracy for non-NEET datasets (like JEE)
-             logging.info("Non-NEET dataset detected (or could not determine). Applying simple accuracy scoring.")
-             # Extract predictions and truths for accuracy calculation
-             predictions_for_acc = [res.get("predicted_answer") for res in model_results if isinstance(res.get("predicted_answer"), list)] # Only use list predictions
-             truths_for_acc = [res.get("ground_truth") for res in model_results if isinstance(res.get("predicted_answer"), list)]
-             # Handle cases where no valid list predictions exist
-             accuracy = 0.0
-             if predictions_for_acc:
-                 try:
-                     # Note: calculate_accuracy expects Optional[List[int]], but we filtered Nones/SKIPs
-                     # We need to align the lists properly if we want to use the original function
-                     # For simplicity here, let's recalculate based on the final model_results
-                     correct_count = 0
-                     valid_attempts = 0
-                     api_parse_failures = 0
-                     for res in model_results:
-                         pred = res.get("predicted_answer")
-                         truth = res.get("ground_truth")
-                         api_success = res.get("api_call_successful")
-                         parse_success = res.get("parse_successful")
-
-                         if not api_success or not parse_success:
-                             api_parse_failures += 1
-                             continue # Count as failure, not incorrect for accuracy
-
-                         valid_attempts += 1
-                         if isinstance(pred, list) and sorted(pred) == sorted(truth):
-                             correct_count += 1
-
-                     accuracy = correct_count / valid_attempts if valid_attempts > 0 else 0.0
-
-                 except ValueError as e:
-                     logging.error(f"Error calculating accuracy for model {model_id}: {e}")
-                     accuracy = 0.0
-             else:
-                 logging.warning(f"No valid list predictions were generated for model {model_id} for accuracy calculation.")
-
-
-             # Determine exam name and year for summary
-             summary_exam_name = exam_name_filter if exam_name_filter else "All_Exams"
-             summary_exam_year = exam_year_filter if exam_year_filter else "All_Years"
-
-             summary = {
-                 "model_name": model_id,
-                 "exam_name": summary_exam_name,
-                 "exam_year": summary_exam_year,
-                 "timestamp": timestamp,
-                 "total_questions_in_dataset": total_questions, # This is total in dataset *before* model processing
-                 "total_processed_attempts": len(model_results), # Includes retries
-                 "successful_api_calls": sum(1 for res in model_results if res.get("api_call_successful")),
-                 "successful_parses": sum(1 for res in model_results if res.get("parse_successful")),
-                 "accuracy_on_parsed": accuracy # Accuracy based only on successfully parsed non-skipped answers
-                 # Note: total_questions_processed is part of evaluation_summary for NEET, handle for non-NEET if needed
-             }
-             logging.info(f"Accuracy (on successfully parsed non-skipped): {accuracy:.4f}")
-
+        
+        # Always use calculate_exam_scores now
+        evaluation_summary = calculate_exam_scores(model_results) # model_results modified in-place
+        
+        summary_exam_name = exam_name_filter if exam_name_filter else "All_Exams"
+        summary_exam_year = exam_year_filter if exam_year_filter else "All_Years"
+
+        summary = {
+            "model_name": model_id,
+            "exam_name": summary_exam_name, # This is the filter, not necessarily from data if no filter
+            "exam_year": summary_exam_year, # This is the filter
+            "timestamp": timestamp,
+            "total_questions_in_dataset": total_questions, 
+            **evaluation_summary 
+        }
+        logging.info(f"Exam Score: {summary.get('overall_score')}")
+        logging.info(f"Full Correct: {summary.get('overall_correct_full')}, Partial Correct: {summary.get('overall_partial_correct')}, Incorrect Choice: {summary.get('overall_incorrect_choice')}, Skipped: {summary.get('overall_skipped')}, API/Parse Failures: {summary.get('overall_api_parse_failures')}")
+        
         logging.info(f"--- Results Summary for model: {model_id} ---")
-        logging.info(json.dumps(summary, indent=2))
+        logging.info(json.dumps(summary, indent=2, sort_keys=True))
         logging.info("-------------------------------------")
 
         # --- Overwrite predictions file with final evaluated results ---

src/evaluation.py

@@ -56,160 +56,235 @@ def calculate_accuracy(predictions: List[Optional[List[int]]], ground_truths: Li
     return accuracy
 
 
-def get_neet_section(subject: str, question_num: int) -> Optional[str]: # question_num is effectively unused by this revised logic
+def get_subject_as_section(subject: str, question_num_for_log: int) -> Optional[str]:
     """
     Returns the subject name directly as the section identifier.
-    This makes the section reporting dynamic based on the 'subject' field from metadata.
+    question_num_for_log is only used for logging context if subject is invalid.
     """
-    if subject and isinstance(subject, str) and subject.strip(): # Ensure subject is a non-empty string
-        return subject.strip() # Return the subject name as is
+    if subject and isinstance(subject, str) and subject.strip():
+        return subject.strip()
     else:
-        # Log if subject is missing or invalid, helps in debugging data issues.
-        # question_num is included in log for context, though not used for determination.
-        logging.warning(f"Invalid or missing subject ('{subject}') for question_num '{question_num}'. Cannot determine section.")
+        logging.warning(f"Invalid or missing subject ('{subject}') for question_num '{question_num_for_log}'. Cannot determine section.")
         return None
 
 
-def calculate_neet_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
     """
-    Calculates NEET scores (+4 / -1 / 0) and provides section-wise breakdown.
+    Calculates exam scores based on exam_name and question_type, providing section-wise breakdown.
 
     Args:
         results (List[Dict[str, Any]]): A list of result dictionaries. Each dict must contain:
-            'question_id' (str): e.g., "NEET_2024_T3_045"
-            'subject' (str): e.g., "Physics"
-            'ground_truth' (List[int]): Correct answer(s)
-            'predicted_answer' (List[int] | str | None): Model's prediction ("SKIP", list, or None)
+            'question_id' (str)
+            'subject' (str)
+            'exam_name' (str) e.g., "NEET", "JEE_MAIN", "JEE_ADVANCED"
+            'question_type' (str) e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER"
+            'ground_truth' (List[int] | int): Correct answer(s). For INTEGER, it's a single int.
+            'predicted_answer' (List[int] | str | None): Model's prediction.
             'api_call_successful' (bool): Whether the API call succeeded.
             This list will be modified in-place to add 'evaluation_status' and 'marks_awarded'.
-
     Returns:
         Dict[str, Any]: A dictionary containing overall and section-wise scores and counts.
     """
     if not results:
         return {"error": "No results provided."}
 
-    # Initialize overall and section counters
-    overall_stats = {"score": 0, "correct": 0, "incorrect": 0, "skipped": 0, "api_parse_failures": 0}
+    overall_stats = {"score": 0, "correct": 0, "incorrect": 0, "skipped": 0, "api_parse_failures": 0, "partial_correct": 0}
     
-    # Dynamically discover subjects from the results and initialize section_stats
-    # Filter out None or empty subjects before creating the set
     valid_subjects_from_data = [r.get("subject") for r in results if r.get("subject") and isinstance(r.get("subject"), str) and r.get("subject").strip()]
-    if not valid_subjects_from_data and results: # If results exist but no valid subjects found
-        logging.warning("No valid subjects found in results data to initialize section_stats, though results were provided.")
+    if not valid_subjects_from_data and results:
+        logging.warning("No valid subjects found in results data to initialize section_stats.")
     
     unique_subjects = sorted(list(set(s.strip() for s in valid_subjects_from_data)))
-    
     section_stats = {
-        subj: {"score": 0, "correct": 0, "incorrect": 0, "skipped": 0}
+        subj: {"score": 0, "correct": 0, "incorrect": 0, "skipped": 0, "api_parse_failures": 0, "partial_correct": 0}
         for subj in unique_subjects
     }
+    if not unique_subjects and results:
+        logging.warning("section_stats is empty because no unique, valid subjects were found.")
     
-    if not unique_subjects and results: # Log if results are present but no sections could be initialized
-        logging.warning("section_stats is empty because no unique, valid subjects were found in the results.")
-    
-    unmapped_questions = 0
+    unmapped_section_questions = 0
 
     for result in results:
         question_id = result.get("question_id")
-        # Use the subject directly from the result item for section mapping.
-        # This 'subject' variable will be passed to get_neet_section.
-        subject = result.get("subject") 
+        subject = result.get("subject")
+        exam_name = result.get("exam_name", "").upper() # Default to empty string, then uppercase
+        question_type = result.get("question_type", "").upper() # Default to empty string, then uppercase
+        
         pred = result.get("predicted_answer")
-        truth = result.get("ground_truth")
-        api_success = result.get("api_call_successful", False) # Default to False if missing
+        truth = result.get("ground_truth") # Can be list for MCQ, int for INTEGER
+        api_success = result.get("api_call_successful", False)
+
+        # Ensure truth is a list for consistent processing, even for single-answer INTEGER types
+        # For INTEGER, ground_truth might be a single int. Convert to list for set operations.
+        if isinstance(truth, int):
+            truth_set = {truth}
+            truth_list_for_comparison = [truth]
+        elif isinstance(truth, list):
+            truth_set = set(truth)
+            truth_list_for_comparison = sorted(truth) # For exact match comparison
+        else:
+            logging.error(f"Invalid ground_truth format for {question_id}: {truth}. Skipping scoring for this question.")
+            result['evaluation_status'] = "error_bad_ground_truth"
+            result['marks_awarded'] = 0
+            overall_stats["api_parse_failures"] +=1 # Count as a type of failure
+            if subject and subject in section_stats:
+                section_stats[subject]["api_parse_failures"] +=1
+            continue
+
 
-        # Determine section
         section = None
-        question_num = -1
-        if question_id and subject:
-            match = re.search(r'_(\d+)$', question_id) # Extract number at the end
-            if match:
+        question_num_for_log = -1 # For logging in get_subject_as_section
+        if question_id:
+            match_num = re.search(r'_(\d+)$', question_id)
+            if match_num:
                 try:
-                    question_num = int(match.group(1))
-                    section = get_neet_section(subject, question_num)
+                    question_num_for_log = int(match_num.group(1))
                 except ValueError:
-                    logging.warning(f"Could not parse number from question_id: {question_id}")
-            else:
-                 logging.warning(f"Could not extract number from question_id format: {question_id}")
-        else:
-            logging.warning(f"Missing question_id or subject for a result: {result}")
-
+                    logging.warning(f"Could not parse number from question_id for logging: {question_id}")
+        
+        if subject:
+            section = get_subject_as_section(subject, question_num_for_log)
+        
         if section is None:
-            unmapped_questions += 1
-            logging.warning(f"Could not map question to NEET section: ID={question_id}, Subject={subject}, Num={question_num}")
-            # Decide how to handle unmapped questions - here we just count them and don't score them section-wise
-            # They will still contribute to overall failure counts if applicable
+            unmapped_section_questions += 1
+            logging.warning(f"Could not map question to section: ID={question_id}, Subject={subject}")
 
-        # --- Scoring Logic ---
         current_score_change = 0
-        is_correct = False
-        is_incorrect = False
+        evaluation_status = "unknown"
+        is_correct_full = False
+        is_incorrect_choice = False # Specifically for choices made that are wrong
         is_skipped = False
-        is_failure = False
-        evaluation_status = "unknown" # Initialize status
-
-        if not api_success or pred is None:
-            # API call failed OR parsing failed (but wasn't a deliberate SKIP)
-            evaluation_status = "failure" # API or Parse Failure
-            is_incorrect = True
-            is_failure = True
-            current_score_change = -1
+        is_api_parse_failure = False # API or internal parsing failure
+        is_partial_correct = False
+
+
+        if not api_success or pred is None: # pred is None means our internal parsing failed
+            is_api_parse_failure = True
+            evaluation_status = "failure_api_or_parse"
+            # Default penalty for API/Parse failure, can be overridden by specific exam rules
+            current_score_change = -1 
+            if exam_name == "JEE_MAIN" and question_type == "INTEGER":
+                current_score_change = 0
+            if exam_name == "JEE_ADVANCED" and question_type == "INTEGER":
+                current_score_change = 0
+            
         elif pred == "SKIP":
             is_skipped = True
             current_score_change = 0
             evaluation_status = "skipped"
-        elif isinstance(pred, list):
-            # API and parsing succeeded, compare answers
-            sorted_pred = sorted(pred)
-            sorted_truth = sorted(truth)
-            # Check if any of the predicted answers are in the ground truth
-            if any(p_ans in sorted_truth for p_ans in sorted_pred):
-                is_correct = True
-                current_score_change = 4
-                evaluation_status = "correct"
+        elif isinstance(pred, list): # LLM provided one or more answer choices
+            pred_set = set(pred)
+            
+            # NEET Scoring
+            if exam_name == "NEET" and question_type == "MCQ_SINGLE_CORRECT":
+                if pred_set == truth_set and len(pred_set) == 1: # NEET is always single correct MCQ
+                    is_correct_full = True; current_score_change = 4; evaluation_status = "correct"
+                else:
+                    is_incorrect_choice = True; current_score_change = -1; evaluation_status = "incorrect"
+            
+            # JEE Main Scoring
+            elif exam_name == "JEE_MAIN":
+                if question_type == "MCQ_SINGLE_CORRECT":
+                    if pred_set == truth_set and len(pred_set) == 1:
+                        is_correct_full = True; current_score_change = 4; evaluation_status = "correct"
+                    else:
+                        is_incorrect_choice = True; current_score_change = -1; evaluation_status = "incorrect"
+                elif question_type == "INTEGER":
+                    # For INTEGER, pred should be a list with one number after parsing
+                    if len(pred) == 1 and pred[0] in truth_set : # truth_set contains the single correct integer
+                        is_correct_full = True; current_score_change = 4; evaluation_status = "correct"
+                    else:
+                        is_incorrect_choice = True; current_score_change = 0; evaluation_status = "incorrect" # No negative for JEE Main Integer
+
+            # JEE Advanced Scoring
+            elif exam_name == "JEE_ADVANCED":
+                if question_type == "MCQ_SINGLE_CORRECT":
+                    if pred_set == truth_set and len(pred_set) == 1:
+                        is_correct_full = True; current_score_change = 3; evaluation_status = "correct"
+                    else:
+                        is_incorrect_choice = True; current_score_change = -1; evaluation_status = "incorrect"
+                elif question_type == "INTEGER":
+                    if len(pred) == 1 and pred[0] in truth_set:
+                        is_correct_full = True; current_score_change = 4; evaluation_status = "correct" # As per image
+                    else:
+                        is_incorrect_choice = True; current_score_change = 0; evaluation_status = "incorrect" # As per image
+                elif question_type == "MCQ_MULTIPLE_CORRECT":
+                    # Complex logic from image
+                    num_correct_options_in_truth = len(truth_set)
+                    num_chosen_options = len(pred_set)
+                    
+                    correct_chosen_options = pred_set.intersection(truth_set)
+                    incorrect_chosen_options = pred_set.difference(truth_set)
+                    
+                    num_correct_chosen = len(correct_chosen_options)
+                    num_incorrect_chosen = len(incorrect_chosen_options)
+
+                    if num_incorrect_chosen > 0:
+                        current_score_change = -2
+                        is_incorrect_choice = True
+                        evaluation_status = "incorrect_negative"
+                    elif num_correct_chosen == num_correct_options_in_truth and num_chosen_options == num_correct_options_in_truth : # All correct and only correct chosen
+                        current_score_change = 4
+                        is_correct_full = True
+                        evaluation_status = "correct_full"
+                    elif num_correct_options_in_truth == 4 and num_correct_chosen == 3 and num_chosen_options == 3: # All 4 are correct, 3 chosen
+                        current_score_change = 3
+                        is_partial_correct = True
+                        evaluation_status = "partial_3_of_4"
+                    elif num_correct_options_in_truth >= 3 and num_correct_chosen == 2 and num_chosen_options == 2: # 3 or more correct, 2 chosen (both correct)
+                        current_score_change = 2
+                        is_partial_correct = True
+                        evaluation_status = "partial_2_of_3_plus"
+                    elif num_correct_options_in_truth >= 2 and num_correct_chosen == 1 and num_chosen_options == 1: # 2 or more correct, 1 chosen (it's correct)
+                        current_score_change = 1
+                        is_partial_correct = True
+                        evaluation_status = "partial_1_of_2_plus"
+                    else: # Other cases not explicitly covered by positive partial, but no incorrect chosen
+                        current_score_change = 0 # Default to 0 if no incorrect, but not matching positive partials
+                        evaluation_status = "no_marks_no_penalty"
             else:
-                is_incorrect = True
-                current_score_change = -1
-                evaluation_status = "incorrect" # Wrong answer
+                logging.warning(f"Unknown exam_name/question_type combination for scoring: {exam_name}/{question_type} for QID {question_id}. Assigning 0 marks.")
+                current_score_change = 0
+                evaluation_status = "unknown_exam_type"
         else:
-            # Should not happen if parsing logic is correct, but handle defensively
-            logging.error(f"Unexpected prediction type for {question_id}: {pred}")
-            is_incorrect = True
-            is_failure = True # Treat unexpected type as failure
-            current_score_change = -1
-            evaluation_status = "failure" # Unexpected type
-
-        # Add evaluation details to the result dictionary
+            # pred is not list and not SKIP and not None (should not happen with current parse_llm_answer)
+            logging.error(f"Unexpected prediction type for {question_id}: {pred}. Treating as API/Parse Failure.")
+            is_api_parse_failure = True
+            current_score_change = -1 # Default penalty
+            evaluation_status = "failure_unexpected_type"
+
+
         result['evaluation_status'] = evaluation_status
         result['marks_awarded'] = current_score_change
 
-        # Update overall stats
         overall_stats["score"] += current_score_change
-        if is_correct: overall_stats["correct"] += 1
-        if is_incorrect: overall_stats["incorrect"] += 1
+        if is_correct_full: overall_stats["correct"] += 1
+        if is_incorrect_choice: overall_stats["incorrect"] += 1 # Only count if a choice was made and it was wrong
         if is_skipped: overall_stats["skipped"] += 1
-        if is_failure: overall_stats["api_parse_failures"] += 1
+        if is_api_parse_failure: overall_stats["api_parse_failures"] += 1
+        if is_partial_correct: overall_stats["partial_correct"] +=1
 
-        # Update section stats if section was determined
-        if section:
+        if section and section in section_stats:
             section_stats[section]["score"] += current_score_change
-            if is_correct: section_stats[section]["correct"] += 1
-            if is_incorrect: section_stats[section]["incorrect"] += 1
+            if is_correct_full: section_stats[section]["correct"] += 1
+            if is_incorrect_choice: section_stats[section]["incorrect"] += 1
             if is_skipped: section_stats[section]["skipped"] += 1
-
-    logging.info(f"NEET Score Calculation Complete. Overall Score: {overall_stats['score']}")
-    if unmapped_questions > 0:
-        logging.warning(f"{unmapped_questions} questions could not be mapped to a NEET section.")
+            if is_api_parse_failure: section_stats[section]["api_parse_failures"] += 1
+            if is_partial_correct: section_stats[section]["partial_correct"] +=1
+            
+    logging.info(f"Exam Score Calculation Complete. Overall Score: {overall_stats['score']}")
+    if unmapped_section_questions > 0:
+        logging.warning(f"{unmapped_section_questions} questions could not be mapped to a section.")
 
     return {
         "overall_score": overall_stats["score"],
-        "overall_correct": overall_stats["correct"],
-        "overall_incorrect": overall_stats["incorrect"],
+        "overall_correct_full": overall_stats["correct"],
+        "overall_partial_correct": overall_stats["partial_correct"],
+        "overall_incorrect_choice": overall_stats["incorrect"],
         "overall_skipped": overall_stats["skipped"],
         "overall_api_parse_failures": overall_stats["api_parse_failures"],
         "total_questions_processed": len(results),
-        "unmapped_section_questions": unmapped_questions,
+        "unmapped_section_questions": unmapped_section_questions,
         "section_breakdown": section_stats
     }
 
@@ -218,107 +293,68 @@ def calculate_neet_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
 if __name__ == '__main__':
     print("Running evaluation tests...")
 
-    # --- Test calculate_accuracy ---
+    # --- Test calculate_accuracy (existing tests can remain as they test general list comparison) ---
     print("\n--- Testing calculate_accuracy ---")
-    # Test case 1: Perfect match
     preds1 = [[1], [2], [1, 3]]
     truths1 = [[1], [2], [3, 1]]
     acc1 = calculate_accuracy(preds1, truths1)
-    print(f"Test Case 1: Preds={preds1}, Truths={truths1} -> Accuracy: {acc1} (Expected: 1.0)")
+    print(f"Test Case 1 (Accuracy): Preds={preds1}, Truths={truths1} -> Accuracy: {acc1} (Expected: 1.0)")
     assert acc1 == 1.0
-
-    # Test case 2: One wrong
-    preds2 = [[1], [4], [1, 3]]
-    truths2 = [[1], [2], [3, 1]]
-    acc2 = calculate_accuracy(preds2, truths2)
-    print(f"Test Case 2: Preds={preds2}, Truths={truths2} -> Accuracy: {acc2} (Expected: ~0.6667)")
-    assert abs(acc2 - 2/3) < 1e-6
-
-    # Test case 3: Parsing failure (None)
-    preds3 = [[1], None, [1, 3]]
-    truths3 = [[1], [2], [3, 1]]
-    acc3 = calculate_accuracy(preds3, truths3)
-    print(f"Test Case 3: Preds={preds3}, Truths={truths3} -> Accuracy: {acc3} (Expected: ~0.6667)")
-    assert abs(acc3 - 2/3) < 1e-6
-
-    # Test case 4: Empty lists
-    preds4 = []
-    truths4 = []
-    acc4 = calculate_accuracy(preds4, truths4)
-    print(f"Test Case 4: Preds={preds4}, Truths={truths4} -> Accuracy: {acc4} (Expected: 0.0)")
-    assert acc4 == 0.0
-
-    # Test case 5: Length mismatch (should raise ValueError)
-    preds5 = [[1]]
-    truths5 = [[1], [2]]
-    try:
-        calculate_accuracy(preds5, truths5)
-        print("Test Case 5: FAILED - ValueError not raised")
-    except ValueError as e:
-        print(f"Test Case 5: PASSED - Raised ValueError: {e}")
-
-    # Test case 6: Partial match in multiple correct is still wrong
-    preds6 = [[1], [2], [1]]
-    truths6 = [[1], [2], [1, 3]]
-    acc6 = calculate_accuracy(preds6, truths6)
-    print(f"Test Case 6: Preds={preds6}, Truths={truths6} -> Accuracy: {acc6} (Expected: ~0.6667)")
-    assert abs(acc6 - 2/3) < 1e-6
-
-    # --- Test calculate_neet_scores ---
-    print("\n--- Testing calculate_neet_scores ---")
-    test_results = [
-        # Physics A - Correct
-        {"question_id": "NEET_2024_T3_001", "subject": "Physics", "ground_truth": [1], "predicted_answer": [1], "api_call_successful": True},
-        # Physics B - Incorrect
-        {"question_id": "NEET_2024_T3_040", "subject": "Physics", "ground_truth": [4], "predicted_answer": [2], "api_call_successful": True},
-        # Chemistry A - Skipped
-        {"question_id": "NEET_2024_T3_055", "subject": "Chemistry", "ground_truth": [4], "predicted_answer": "SKIP", "api_call_successful": True},
-        # Chemistry B - API Fail
-        {"question_id": "NEET_2024_T3_090", "subject": "Chemistry", "ground_truth": [3], "predicted_answer": None, "api_call_successful": False},
-        # Botany A - Parse Fail (None)
-        {"question_id": "NEET_2024_T3_110", "subject": "Botany", "ground_truth": [4], "predicted_answer": None, "api_call_successful": True},
-        # Botany B - Correct (multi)
-        {"question_id": "NEET_2024_T3_145", "subject": "Botany", "ground_truth": [2, 4], "predicted_answer": [4, 2], "api_call_successful": True}, # Assuming multi-correct allowed
-        # Zoology A - Correct
-        {"question_id": "NEET_2024_T3_160", "subject": "Zoology", "ground_truth": [4], "predicted_answer": [4], "api_call_successful": True},
-        # Zoology B - Incorrect
-        {"question_id": "NEET_2024_T3_190", "subject": "Zoology", "ground_truth": [2], "predicted_answer": [1], "api_call_successful": True},
-        # Unmapped ID
-        {"question_id": "JEE_2023_Q1", "subject": "Physics", "ground_truth": [1], "predicted_answer": [1], "api_call_successful": True},
-        # Missing Subject
-        {"question_id": "NEET_2024_T3_002", "subject": None, "ground_truth": [3], "predicted_answer": [3], "api_call_successful": True},
+    # ... (other accuracy tests can be kept or adapted if needed)
+
+
+    # --- Test calculate_exam_scores ---
+    print("\n--- Testing calculate_exam_scores ---")
+    test_results_exam = [
+        # NEET
+        {"question_id": "N001", "subject": "Physics", "exam_name": "NEET", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [1], "predicted_answer": [1], "api_call_successful": True}, # Correct +4
+        {"question_id": "N002", "subject": "Physics", "exam_name": "NEET", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [4], "predicted_answer": [2], "api_call_successful": True}, # Incorrect -1
+        {"question_id": "N003", "subject": "Chemistry", "exam_name": "NEET", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [4], "predicted_answer": "SKIP", "api_call_successful": True}, # Skipped 0
+        {"question_id": "N004", "subject": "Chemistry", "exam_name": "NEET", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [3], "predicted_answer": None, "api_call_successful": False}, # API Fail -1
+        {"question_id": "N005", "subject": "Botany", "exam_name": "NEET", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [4], "predicted_answer": None, "api_call_successful": True}, # Parse Fail -1
+
+        # JEE Main - MCQ
+        {"question_id": "JM001", "subject": "Maths", "exam_name": "JEE_MAIN", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [2], "predicted_answer": [2], "api_call_successful": True}, # Correct +4
+        {"question_id": "JM002", "subject": "Maths", "exam_name": "JEE_MAIN", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [3], "predicted_answer": [1], "api_call_successful": True}, # Incorrect -1
+        # JEE Main - Integer
+        {"question_id": "JM003", "subject": "Physics", "exam_name": "JEE_MAIN", "question_type": "INTEGER", "ground_truth": 5, "predicted_answer": [5], "api_call_successful": True}, # Correct +4
+        {"question_id": "JM004", "subject": "Physics", "exam_name": "JEE_MAIN", "question_type": "INTEGER", "ground_truth": 10, "predicted_answer": [8], "api_call_successful": True}, # Incorrect 0
+        {"question_id": "JM005", "subject": "Chemistry", "exam_name": "JEE_MAIN", "question_type": "INTEGER", "ground_truth": 7, "predicted_answer": None, "api_call_successful": True}, # Parse Fail 0
+
+        # JEE Advanced - MCQ Single Correct
+        {"question_id": "JA001", "subject": "Maths", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [1], "predicted_answer": [1], "api_call_successful": True}, # Correct +3
+        {"question_id": "JA002", "subject": "Maths", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": [2], "predicted_answer": [3], "api_call_successful": True}, # Incorrect -1
+        # JEE Advanced - Integer
+        {"question_id": "JA003", "subject": "Physics", "exam_name": "JEE_ADVANCED", "question_type": "INTEGER", "ground_truth": 12, "predicted_answer": [12], "api_call_successful": True}, # Correct +4
+        {"question_id": "JA004", "subject": "Physics", "exam_name": "JEE_ADVANCED", "question_type": "INTEGER", "ground_truth": 0, "predicted_answer": [1], "api_call_successful": True}, # Incorrect 0
+        # JEE Advanced - MCQ Multiple Correct
+        {"question_id": "JA005", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1, 3], "predicted_answer": [1, 3], "api_call_successful": True}, # All Correct +4
+        {"question_id": "JA006", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1, 2, 3], "predicted_answer": [1, 2], "api_call_successful": True}, # Partial +2 (3 correct, 2 chosen)
+        {"question_id": "JA007", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1, 2, 3, 4], "predicted_answer": [1, 2, 3], "api_call_successful": True}, # Partial +3 (4 correct, 3 chosen)
+        {"question_id": "JA008", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1, 2], "predicted_answer": [1], "api_call_successful": True}, # Partial +1 (2 correct, 1 chosen)
+        {"question_id": "JA009", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1, 3], "predicted_answer": [1, 2], "api_call_successful": True}, # Incorrect option chosen -2
+        {"question_id": "JA010", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1, 3], "predicted_answer": [2, 4], "api_call_successful": True}, # All incorrect options chosen -2
+        {"question_id": "JA011", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1, 3], "predicted_answer": "SKIP", "api_call_successful": True}, # Skipped 0
+        {"question_id": "JA012", "subject": "Maths", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1], "predicted_answer": [1], "api_call_successful": True}, # Single correct in multi-choice, full marks +4
+        {"question_id": "JA013", "subject": "Physics", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": [1,2,3], "predicted_answer": [1,4], "api_call_successful": True}, # One correct, one incorrect -> -2
     ]
 
-    neet_summary = calculate_neet_scores(test_results)
-    print("\nNEET Score Summary:")
+    exam_summary = calculate_exam_scores(test_results_exam)
+    print("\nExam Score Summary:")
     import json
-    print(json.dumps(neet_summary, indent=2))
-
-    # Expected:
-    # Overall: Score=4-1+0-1-1+4+4-1 = 8. Correct=3, Incorrect=4, Skipped=1, Failures=2, Unmapped=2
-    # Phys A: Score=4, Correct=1, Incorrect=0, Skipped=0
-    # Phys B: Score=-1, Correct=0, Incorrect=1, Skipped=0
-    # Chem A: Score=0, Correct=0, Incorrect=0, Skipped=1
-    # Chem B: Score=-1, Correct=0, Incorrect=1, Skipped=0 (API Fail counts as incorrect)
-    # Bot A: Score=-1, Correct=0, Incorrect=1, Skipped=0 (Parse Fail counts as incorrect)
-    # Bot B: Score=4, Correct=1, Incorrect=0, Skipped=0
-    # Zoo A: Score=4, Correct=1, Incorrect=0, Skipped=0
-    # Zoo B: Score=-1, Correct=0, Incorrect=1, Skipped=0
-
-    assert neet_summary["overall_score"] == 8
-    assert neet_summary["overall_correct"] == 3
-    assert neet_summary["overall_incorrect"] == 4
-    assert neet_summary["overall_skipped"] == 1
-    assert neet_summary["overall_api_parse_failures"] == 2
-    assert neet_summary["unmapped_section_questions"] == 2
-    assert neet_summary["section_breakdown"]["Physics_A"]["score"] == 4
-    assert neet_summary["section_breakdown"]["Physics_B"]["score"] == -1
-    assert neet_summary["section_breakdown"]["Chemistry_A"]["score"] == 0
-    assert neet_summary["section_breakdown"]["Chemistry_B"]["score"] == -1
-    assert neet_summary["section_breakdown"]["Botany_A"]["score"] == -1
-    assert neet_summary["section_breakdown"]["Botany_B"]["score"] == 4
-    assert neet_summary["section_breakdown"]["Zoology_A"]["score"] == 4
-    assert neet_summary["section_breakdown"]["Zoology_B"]["score"] == -1
-
+    print(json.dumps(exam_summary, indent=2, sort_keys=True))
+
+    # Basic assertions - can be expanded
+    assert exam_summary["overall_score"] == (4-1+0-1-1) + (4-1) + (4+0+0) + (3-1) + (4+0) + (4+2+3+1-2-2+0+4-2)
+    assert exam_summary["overall_correct_full"] == 8
+    assert exam_summary["overall_partial_correct"] == 3
+    assert exam_summary["overall_incorrect_choice"] == 7
+    assert exam_summary["overall_skipped"] == 2
+    assert exam_summary["overall_api_parse_failures"] == 3 # N004, N005, JM005
+
+    assert exam_summary["section_breakdown"]["Physics"]["score"] == (4-1) + (4+0) + (4+0) - 2 # N001,N002 + JM003,JM004 + JA003,JA004 + JA013
+    assert exam_summary["section_breakdown"]["Chemistry"]["score"] == (0-1) + (0) + (4+2+3+1-2-2+0) # N003,N004 + JM005 + JA005-JA011
+    assert exam_summary["section_breakdown"]["Botany"]["score"] == -1 # N005
+    assert exam_summary["section_breakdown"]["Maths"]["score"] == (4-1) + (3-1) + 4 # JM001,JM002 + JA001,JA002 + JA012
 
     print("\nEvaluation tests completed.")

src/llm_interface.py

@@ -42,45 +42,69 @@ def encode_image_to_base64(image: Image.Image) -> str:
     img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
     return img_str
 
-def construct_reprompt_prompt(previous_raw_response: str) -> list:
-    """Constructs the message list for a re-prompt API call."""
+def construct_reprompt_prompt(previous_raw_response: str, question_type: str) -> list:
+    """Constructs the message list for a re-prompt API call based on question_type."""
+    specific_instructions = ""
+    if question_type == "MCQ_SINGLE_CORRECT":
+        specific_instructions = "provide ONLY the single integer corresponding to the correct answer choice"
+    elif question_type == "INTEGER":
+        specific_instructions = "provide ONLY the single non-negative integer that is the answer"
+    elif question_type == "MCQ_MULTIPLE_CORRECT":
+        specific_instructions = "provide ALL correct integer option(s) separated by commas (e.g., <answer>1,3</answer> or <answer>2</answer> if only one is correct)"
+    else: # Default or unknown
+        specific_instructions = "provide the answer according to the question format"
+
     prompt_text = f"""You previously provided the following response to an exam question:
 --- PREVIOUS RESPONSE START ---
 {previous_raw_response}
 --- PREVIOUS RESPONSE END ---
 
-Your previous response did not correctly format the final answer within <answer> tags, or it contained multiple answers.
-
-For NEET exam questions, only a single answer option is correct.
+Your previous response did not correctly format the final answer within <answer> tags, or it did not match the expected format for a '{question_type}' question.
 
-Please re-examine your previous reasoning and provide ONLY the single integer corresponding to the correct answer choice, enclosed in <answer> tags.
+Please re-examine your previous reasoning and {specific_instructions}, enclosed in <answer> tags.
 
-Example:
-- If the correct option is 2: <answer>2</answer>
-- If you are unsure or cannot determine the answer: <answer>SKIP</answer>
+Example for single correct integer: <answer>2</answer>
+Example for multiple correct integers: <answer>1,4</answer>
+If you are unsure or cannot determine the answer: <answer>SKIP</answer>
 
-It is crucial that your response contains ONLY the <answer> tag with the single correct integer number OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
+It is crucial that your response contains ONLY the <answer> tag with the correct integer(s) OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
     messages = [{"role": "user", "content": prompt_text}]
     return messages
 
 
-def construct_initial_prompt(base64_image: str, exam_name: str, exam_year: str) -> list:
-    """Constructs the initial message list with image for the OpenRouter API call."""
-    # Updated prompt for the first attempt
-    prompt_text = f"""You are an expert at analyzing exam questions from the {exam_name} {exam_year} exam and extracting the correct answer option.
-This exam uses positive marking for correct answers and may use negative marking for incorrect answers, so accuracy is crucial.
+def construct_initial_prompt(base64_image: str, exam_name: str, exam_year: str, question_type: str) -> list:
+    """Constructs the initial message list with image for the OpenRouter API call, tailored by question_type."""
+    
+    answer_format_instruction = ""
+    example_instruction = ""
+
+    if question_type == "MCQ_SINGLE_CORRECT":
+        answer_format_instruction = "determine the single correct integer number corresponding to the correct option."
+        example_instruction = "- If the correct option is 2: <answer>2</answer>"
+    elif question_type == "INTEGER":
+        answer_format_instruction = "determine the single non-negative integer that is the answer."
+        example_instruction = "- If the answer is 5: <answer>5</answer>"
+    elif question_type == "MCQ_MULTIPLE_CORRECT":
+        answer_format_instruction = "determine all correct integer option(s). If multiple options are correct, list them separated by commas."
+        example_instruction = "- If options 1 and 3 are correct: <answer>1,3</answer>\n- If only option 2 is correct: <answer>2</answer>"
+    else: # Default or unknown
+        answer_format_instruction = "determine the correct answer."
+        example_instruction = "- Example: <answer>Your Answer</answer>"
+
+    prompt_text = f"""You are an expert at analyzing exam questions from the {exam_name} {exam_year} exam ({question_type}) and extracting the correct answer option(s).
+This exam uses specific marking schemes, so accuracy and correct formatting are crucial.
 
 Please think step-by-step to solve the problem.
-Examine the provided image of a multiple-choice question carefully.
-1. Analyze the question and the provided options.
-2. Reason through the problem to determine the single correct integer number corresponding to the correct option.
-3. Format your final answer by enclosing ONLY the single integer number within <answer> tags.
+Examine the provided image of the question carefully.
+1. Analyze the question and the provided options (if any).
+2. Reason through the problem to {answer_format_instruction}
+3. Format your final answer by enclosing ONLY the determined integer(s) within <answer> tags.
 
 Examples:
-- If the correct option is 2: <answer>2</answer>
+{example_instruction}
 - If you are unsure or cannot determine the answer: <answer>SKIP</answer>
 
-It is crucial that your response contains ONLY the <answer> tag with the single correct integer number OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
+It is crucial that your response contains ONLY the <answer> tag with the correct integer(s) OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
 
     messages = [
         {
@@ -104,8 +128,9 @@ def get_openrouter_prediction(
     api_key: str,
     image: Image.Image | None = None, # Image is now optional
     previous_raw_response: str | None = None, # Added for re-prompting
-    exam_name: str | None = None, # New parameter
-    exam_year: str | None = None, # New parameter
+    exam_name: str | None = None, 
+    exam_year: str | None = None, 
+    question_type: str = "MCQ_SINGLE_CORRECT", # New parameter with default
     max_tokens: int = 100,
     request_timeout: int = 60
 ) -> tuple[list[int] | str | None, str | None]: # Allow predicted_answer to be "SKIP"
@@ -117,8 +142,9 @@ def get_openrouter_prediction(
         api_key (str): The OpenRouter API key.
         image (Image.Image | None): The question image (for initial prompt). Default None.
         previous_raw_response (str | None): The raw response from a previous failed parse attempt (for re-prompt). Default None.
-        exam_name (str | None): The name of the exam (e.g., "NEET", "JEE"). Required if 'image' is provided.
-        exam_year (str | None): The year of the exam. Required if 'image' is provided.
+        exam_name (str | None): The name of the exam (e.g., "NEET", "JEE"). Required if 'image' is provided for initial prompt.
+        exam_year (str | None): The year of the exam. Required if 'image' is provided for initial prompt.
+        question_type (str): Type of question, e.g., "MCQ_SINGLE_CORRECT", "MCQ_MULTIPLE_CORRECT", "INTEGER".
         max_tokens (int): Max tokens for the response.
         request_timeout (int): Timeout for the API request in seconds.
 
@@ -128,24 +154,28 @@ def get_openrouter_prediction(
             - The raw response text from the LLM (or None if API call failed).
 
     Raises:
-        ValueError: If neither image nor previous_raw_response is provided.
+        ValueError: If arguments are inconsistent (e.g., image provided without exam details for initial prompt).
         requests.exceptions.RequestException: If the API call fails after retries.
     """
-    logging.info(f"Requesting prediction from model: {model_identifier}")
+    logging.info(f"Requesting prediction from model: {model_identifier} for question_type: {question_type}")
 
     if image is not None and previous_raw_response is None:
         # Initial prompt with image
-        if not exam_name or not exam_year:
+        if not exam_name or not exam_year: # exam_name and exam_year are crucial for initial prompt context
             raise ValueError("'exam_name' and 'exam_year' must be provided when 'image' is specified for an initial prompt.")
-        logging.debug(f"Constructing initial prompt with image for {exam_name} {exam_year}.")
+        logging.debug(f"Constructing initial prompt with image for {exam_name} {exam_year}, type: {question_type}.")
         base64_image = encode_image_to_base64(image)
-        messages = construct_initial_prompt(base64_image, exam_name, exam_year)
+        messages = construct_initial_prompt(base64_image, exam_name, exam_year, question_type)
     elif image is None and previous_raw_response is not None:
         # Re-prompt based on previous response
-        logging.debug("Constructing re-prompt based on previous response.")
-        messages = construct_reprompt_prompt(previous_raw_response)
+        logging.debug(f"Constructing re-prompt based on previous response for type: {question_type}.")
+        messages = construct_reprompt_prompt(previous_raw_response, question_type)
     else:
-        raise ValueError("Either 'image' (for initial call) or 'previous_raw_response' (for re-prompt) must be provided, but not both.")
+        # This condition means either both image and previous_raw_response are None, or both are provided.
+        # The latter (both provided) is ambiguous for which prompt to use.
+        # The former (both None) means no input to act on.
+        raise ValueError("Provide 'image' (with 'exam_name' and 'exam_year') for an initial call, OR 'previous_raw_response' for a re-prompt. Not neither or both.")
+
 
     try:
         headers = {
@@ -166,91 +196,94 @@ def get_openrouter_prediction(
             timeout=request_timeout
         )
 
-        # Handle specific status code retries (though tenacity handles exceptions)
         if response.status_code in RETRYABLE_STATUS_CODES:
-            logging.warning(f"Received retryable status code {response.status_code} from {model_identifier}. Retrying might occur if configured.")
-            # Raise an exception to trigger tenacity retry based on status code if needed,
-            # or handle retry logic more explicitly here if preferred.
-            # For simplicity, we rely on tenacity for exception-based retries.
-            # If the request fails multiple times with these codes, it will eventually raise.
-            response.raise_for_status() # Raise HTTPError for bad status codes after retries fail
-
-        # Handle non-retryable client/server errors
+            logging.warning(f"Received retryable status code {response.status_code} from {model_identifier} for {question_type}. Retrying might occur.")
+            response.raise_for_status() 
+
         if not response.ok:
-            logging.error(f"API Error for model {model_identifier}: Status {response.status_code} - {response.text}")
-            return None, None # Failed API call
+            logging.error(f"API Error for model {model_identifier} ({question_type}): Status {response.status_code} - {response.text}")
+            return None, None 
 
         response_json = response.json()
         raw_response_text = response_json.get("choices", [{}])[0].get("message", {}).get("content")
 
         if not raw_response_text:
-            logging.warning(f"Empty response content received from model: {model_identifier}")
+            logging.warning(f"Empty response content received from model: {model_identifier} for {question_type}")
             return None, None
 
-        logging.info(f"Raw response received from {model_identifier}: '{raw_response_text[:100]}...'")
-        parsed_answer = parse_llm_answer(raw_response_text)
+        logging.info(f"Raw response received from {model_identifier} ({question_type}): '{raw_response_text[:100]}...'")
+        # Pass question_type to parse_llm_answer
+        parsed_answer = parse_llm_answer(raw_response_text, question_type=question_type) 
 
         if parsed_answer is None:
-             logging.warning(f"Failed to parse answer from model {model_identifier}.") # Simplified log
+             logging.warning(f"Failed to parse answer from model {model_identifier} for {question_type}.")
 
         return parsed_answer, raw_response_text
 
     except requests.exceptions.Timeout as e:
-        logging.error(f"Request timed out for model {model_identifier}: {e}")
-        raise  # Re-raise to allow tenacity to handle retry
+        logging.error(f"Request timed out for model {model_identifier} ({question_type}): {e}")
+        raise 
     except requests.exceptions.RequestException as e:
-        logging.error(f"Request failed for model {model_identifier}: {e}")
-        raise # Re-raise to allow tenacity to handle retry
+        logging.error(f"Request failed for model {model_identifier} ({question_type}): {e}")
+        raise 
     except Exception as e:
-        logging.error(f"An unexpected error occurred for model {model_identifier}: {e}")
-        # Don't re-raise unexpected errors unless retry logic is designed for them
-        return None, None # Failed due to unexpected error
+        logging.error(f"An unexpected error occurred for model {model_identifier} ({question_type}): {e}")
+        return None, None
 
 # Example Usage (requires a valid API key in .env and Pillow/requests/tenacity installed)
 if __name__ == '__main__':
     from src.utils import load_api_key
     try:
-        # Create a dummy black image for testing
         dummy_image = Image.new('RGB', (60, 30), color = 'black')
         api_key = load_api_key()
-        # Replace with a model you have access to via OpenRouter, e.g., "openai/gpt-4o"
-        # Note: Free models might not support vision or follow instructions well.
-        test_model = "anthropic/claude-3-haiku" # Example model
-
-        print(f"\nTesting prediction with model: {test_model}")
-        # Example with image, requiring exam_name and exam_year
-        parsed_ans, raw_resp = get_openrouter_prediction(
-            model_identifier=test_model,
-            api_key=api_key,
-            image=dummy_image,
-            exam_name="DUMMY_EXAM",
-            exam_year="2024"
+        test_model = "anthropic/claude-3-haiku" 
+
+        print(f"\n--- Testing with model: {test_model} ---")
+
+        # Test Case 1: Initial call - MCQ_SINGLE_CORRECT
+        print("\nTest Case 1: Initial - MCQ_SINGLE_CORRECT")
+        parsed_ans_1, raw_resp_1 = get_openrouter_prediction(
+            model_identifier=test_model, api_key=api_key, image=dummy_image,
+            exam_name="DUMMY_EXAM", exam_year="2024", question_type="MCQ_SINGLE_CORRECT"
         )
+        print(f"Parsed: {parsed_ans_1}, Raw: {raw_resp_1[:60] if raw_resp_1 else None}...")
 
-        print(f"Model: {test_model}")
-        print(f"Parsed Answer (Initial): {parsed_ans}")
-        print(f"Raw Response (Initial): {raw_resp}")
-
-        # Example re-prompt (does not need image, exam_name, or exam_year)
-        if raw_resp: # Only attempt re-prompt if there was an initial response
-            print(f"\nTesting re-prompt for model: {test_model}")
-            reprompt_ans, reprompt_raw_resp = get_openrouter_prediction(
-                model_identifier=test_model,
-                api_key=api_key,
-                previous_raw_response="<answer>1 2</answer> This is some extra text." # Example bad response
-            )
-            print(f"Parsed Answer (Re-prompt): {reprompt_ans}")
-            print(f"Raw Response (Re-prompt): {reprompt_raw_resp}")
-        else:
-            print("\nSkipping re-prompt test as initial response was empty.")
+        # Test Case 2: Initial call - MCQ_MULTIPLE_CORRECT
+        print("\nTest Case 2: Initial - MCQ_MULTIPLE_CORRECT")
+        parsed_ans_2, raw_resp_2 = get_openrouter_prediction(
+            model_identifier=test_model, api_key=api_key, image=dummy_image,
+            exam_name="DUMMY_EXAM", exam_year="2024", question_type="MCQ_MULTIPLE_CORRECT"
+        )
+        print(f"Parsed: {parsed_ans_2}, Raw: {raw_resp_2[:60] if raw_resp_2 else None}...")
+
+        # Test Case 3: Initial call - INTEGER
+        print("\nTest Case 3: Initial - INTEGER")
+        parsed_ans_3, raw_resp_3 = get_openrouter_prediction(
+            model_identifier=test_model, api_key=api_key, image=dummy_image,
+            exam_name="DUMMY_EXAM", exam_year="2024", question_type="INTEGER"
+        )
+        print(f"Parsed: {parsed_ans_3}, Raw: {raw_resp_3[:60] if raw_resp_3 else None}...")
+
+
+        # Test Case 4: Re-prompt - MCQ_SINGLE_CORRECT (simulating bad initial response)
+        print("\nTest Case 4: Re-prompt - MCQ_SINGLE_CORRECT")
+        bad_initial_resp_mcq_single = "<answer>1 2</answer> This is some extra text."
+        reprompt_ans_4, reprompt_raw_4 = get_openrouter_prediction(
+            model_identifier=test_model, api_key=api_key,
+            previous_raw_response=bad_initial_resp_mcq_single, question_type="MCQ_SINGLE_CORRECT"
+        )
+        print(f"Parsed: {reprompt_ans_4}, Raw: {reprompt_raw_4[:60] if reprompt_raw_4 else None}...")
+
+        # Test Case 5: Re-prompt - MCQ_MULTIPLE_CORRECT (simulating bad initial response)
+        print("\nTest Case 5: Re-prompt - MCQ_MULTIPLE_CORRECT")
+        bad_initial_resp_mcq_multi = "The answer is <answer>option 1 and 4</answer> because reasons."
+        reprompt_ans_5, reprompt_raw_5 = get_openrouter_prediction(
+            model_identifier=test_model, api_key=api_key,
+            previous_raw_response=bad_initial_resp_mcq_multi, question_type="MCQ_MULTIPLE_CORRECT"
+        )
+        print(f"Parsed: {reprompt_ans_5}, Raw: {reprompt_raw_5[:60] if reprompt_raw_5 else None}...")
 
     except ValueError as e:
-        print(f"Setup Error: {e}")
-    # The following Exception catch was too broad and could mask the raw_resp not being defined
-    # if the ValueError for setup occurred first.
-    # It's better to catch a more general Exception for runtime issues after setup.
+        print(f"Setup or Argument Error: {e}")
     except Exception as e:
-        # Check if raw_resp was defined (e.g. if initial call succeeded but re-prompt failed)
-        # This is a bit tricky as raw_resp might be from a successful first call even if a later part fails.
-        # For simplicity in an example, just print the runtime error.
         print(f"Runtime Error during example execution: {e}")

src/utils.py

@@ -28,103 +28,119 @@ def load_api_key(key_name="OPENROUTER_API_KEY"):
     return api_key
 
 
-def parse_llm_answer(response_text: str) -> list[int] | str | None:
+def parse_llm_answer(response_text: str, question_type: str = "MCQ_SINGLE_CORRECT") -> list[int] | str | None:
     """
     Parses the LLM response text to extract answers within <answer> tags.
-    Requires exactly one integer answer for NEET context.
+    The parsing logic adapts based on the question_type.
 
     Handles:
-    - Single integer answers.
+    - Single integer answers (for MCQ_SINGLE_CORRECT, INTEGER).
+    - Multiple integer answers (comma-separated for MCQ_MULTIPLE_CORRECT).
     - The specific string "SKIP" for skipped questions.
     - Potential newlines within the tags.
 
     Args:
         response_text (str): The raw text response from the LLM.
+        question_type (str): The type of question, e.g., "MCQ_SINGLE_CORRECT",
+                             "MCQ_MULTIPLE_CORRECT", "INTEGER".
+                             Defaults to "MCQ_SINGLE_CORRECT".
 
     Returns:
         list[int] | str | None:
-            - A list containing the single integer answer if found and valid.
+            - A list containing integer answer(s) if found and valid.
+              (single element for MCQ_SINGLE_CORRECT/INTEGER, potentially multiple for MCQ_MULTIPLE_CORRECT)
             - The string "SKIP" if the response indicates a skip.
-            - None if parsing fails (no tag, invalid content, multiple answers, etc.).
+            - None if parsing fails (no tag, invalid content, type mismatch, etc.).
     """
     if not response_text:
         return None
 
     # Check for exact SKIP response first (case-insensitive)
-    # Use strip() to handle potential leading/trailing whitespace around the tag itself
     if response_text.strip().upper() == "<ANSWER>SKIP</ANSWER>":
-        logging.info("Parsed answer as SKIP.")
+        logging.info(f"Parsed answer as SKIP for question_type: {question_type}.")
         return "SKIP"
 
-    # Regex to find content within <answer>...</answer>, allowing for newlines (re.DOTALL)
-    # It captures the content inside the tags.
     match = re.search(r"<answer>(.*?)</answer>", response_text, re.DOTALL | re.IGNORECASE)
 
-    if match:
-        extracted_content = match.group(1).strip()
-        logging.debug(f"DEBUG_PARSE: Raw extracted content: {match.group(1)!r}, Stripped: {extracted_content!r}") # Changed to debug
-        if not extracted_content:
-            logging.warning(f"Found <answer> tag but content is empty.")
-            return None # Empty content within tags
-
-        # Split by comma and strip whitespace for each potential number
-        potential_answers = [item.strip() for item in extracted_content.split(',')]
-
-        parsed_answers = []
-        valid = True
-        for ans_str in potential_answers:
-            if not ans_str: continue # Skip empty strings resulting from trailing commas etc.
-            try:
-                logging.debug(f"DEBUG_PARSE: Attempting int conversion on: {ans_str!r}") # Changed to debug
-                # Attempt to convert to integer
-                parsed_answers.append(int(ans_str))
-            except ValueError:
-                # Log only the problematic part, not the whole content
-                logging.warning(f"Could not parse '{ans_str}' as an integer within <answer> tag.")
-                valid = False
-                break # Stop parsing this tag content if any part is invalid
-
-        if valid and len(parsed_answers) == 1:
-            # Return list with the single integer answer
-            return parsed_answers # No need to sort a single-element list
-        elif valid and len(parsed_answers) > 1:
-             logging.warning(f"Found multiple answers ({parsed_answers}) within <answer> tag. Treating as parse failure for single-answer context.")
-             return None # Treat multiple answers as failure
+    if not match:
+        logging.warning(f"Could not find <answer> tag in response for question_type: {question_type}.")
+        return None
+
+    extracted_content = match.group(1).strip()
+    if not extracted_content:
+        logging.warning(f"Found <answer> tag but content is empty for question_type: {question_type}.")
+        return None
+
+    potential_answers_str = [item.strip() for item in extracted_content.split(',')]
+    parsed_numbers = []
+    all_valid_numbers = True
+
+    for ans_str in potential_answers_str:
+        if not ans_str: continue # Skip empty strings (e.g., from "1," or ",2")
+        try:
+            parsed_numbers.append(int(ans_str))
+        except ValueError:
+            logging.warning(f"Could not parse '{ans_str}' as an integer within <answer> tag for question_type: {question_type}.")
+            all_valid_numbers = False
+            break
+
+    if not all_valid_numbers or not parsed_numbers: # If any part was not a number or if list is empty after parsing
+        return None
+
+    # Apply rules based on question_type
+    if question_type in ["MCQ_SINGLE_CORRECT", "INTEGER"]:
+        if len(parsed_numbers) == 1:
+            return parsed_numbers # Returns [integer]
         else:
-            # Parsing failed (invalid content) or resulted in empty list after validation
-            # No need to log here, handled by the ValueError log above if applicable
+            logging.warning(f"Expected single answer for {question_type}, but found {len(parsed_numbers)} numbers: {parsed_numbers}. Treating as parse failure.")
             return None
+    elif question_type == "MCQ_MULTIPLE_CORRECT":
+        # For multiple correct, any number of valid integers is acceptable.
+        # Return them sorted and unique.
+        return sorted(list(set(parsed_numbers)))
     else:
-        # Tag not found
-        logging.warning(f"Could not find <answer> tag in response.") # Simplified log
-        return None # Return None if tag is missing, fallback removed
+        logging.error(f"Unknown question_type '{question_type}' provided to parse_llm_answer.")
+        return None
 
 # Example Usage (for testing)
 if __name__ == '__main__':
-    test_responses = [
-        "Some text before <answer>2</answer> and after.",
-        "Blah blah <answer> 1 </answer> blah",
-        "<answer>1,3</answer>", # Should fail now
-        "<answer> 4 , 2 </answer> end", # Should fail now
-        "<answer>\n 3 \n</answer>",
-        "<answer>\n 1,\n 4 \n</answer>", # Should fail now
-        "No answer tag here.", # Should fail now
-        "<answer></answer>",
-        "<answer>  </answer>",
-        "<answer>abc</answer>",
-        "<answer>1, abc</answer>",
-        "<answer>1, </answer>", # Should fail now
-        "<answer>,2</answer>", # Should fail now
-        None,
-        "",
-        "<ANSWER>SKIP</ANSWER>",
-        " <ANSWER>SKIP</ANSWER> "
+    test_cases = [
+        # MCQ_SINGLE_CORRECT / INTEGER
+        {"resp": "Some text before <answer>2</answer> and after.", "type": "MCQ_SINGLE_CORRECT", "expected": [2]},
+        {"resp": "Blah blah <answer> 1 </answer> blah", "type": "INTEGER", "expected": [1]},
+        {"resp": "<answer>\n 3 \n</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": [3]},
+        {"resp": "<answer>1,3</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None}, # Fail: multiple for single
+        {"resp": "<answer>1,3</answer>", "type": "INTEGER", "expected": None}, # Fail: multiple for single
+        {"resp": "No answer tag here.", "type": "MCQ_SINGLE_CORRECT", "expected": None},
+        {"resp": "<answer></answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
+        {"resp": "<answer>  </answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
+        {"resp": "<answer>abc</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
+        {"resp": "<answer>1, abc</answer>", "type": "MCQ_SINGLE_CORRECT", "expected": None},
+        {"resp": "<ANSWER>SKIP</ANSWER>", "type": "MCQ_SINGLE_CORRECT", "expected": "SKIP"},
+        {"resp": " <ANSWER>SKIP</ANSWER> ", "type": "INTEGER", "expected": "SKIP"},
+
+        # MCQ_MULTIPLE_CORRECT
+        {"resp": "<answer>1,3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1, 3]},
+        {"resp": "<answer> 4 , 2 </answer> end", "type": "MCQ_MULTIPLE_CORRECT", "expected": [2, 4]},
+        {"resp": "<answer>\n 1,\n 4 \n</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1, 4]},
+        {"resp": "<answer>3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [3]}, # Single is valid for multi
+        {"resp": "<answer>3,1,4,1</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1, 3, 4]}, # Unique and sorted
+        {"resp": "<answer>1, </answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [1]}, # Handles trailing comma
+        {"resp": "<answer>,2</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": [2]}, # Handles leading comma
+        {"resp": "<answer>1,abc,3</answer>", "type": "MCQ_MULTIPLE_CORRECT", "expected": None}, # Invalid content
+        {"resp": "<ANSWER>SKIP</ANSWER>", "type": "MCQ_MULTIPLE_CORRECT", "expected": "SKIP"},
+
+        # General / Edge cases
+        {"resp": None, "type": "MCQ_SINGLE_CORRECT", "expected": None},
+        {"resp": "", "type": "MCQ_SINGLE_CORRECT", "expected": None},
+        {"resp": "<answer>5</answer>", "type": "UNKNOWN_TYPE", "expected": None}, # Unknown type
     ]
 
-    print("\n--- Testing parse_llm_answer (single answer required) ---")
-    for resp in test_responses:
-        parsed = parse_llm_answer(resp)
-        print(f"Response: '{str(resp)[:50]}...' -> Parsed: {parsed}")
+    print("\n--- Testing parse_llm_answer (with question_type) ---")
+    for case in test_cases:
+        parsed = parse_llm_answer(case["resp"], case["type"])
+        print(f"Response: '{str(case['resp'])[:50]}...', Type: {case['type']} -> Parsed: {parsed} (Expected: {case['expected']})")
+        assert parsed == case["expected"], f"Mismatch for {case['resp']} with type {case['type']}"
 
     # Test API key loading (will raise error if .env or env var not set)
     # try: