import logging import re from typing import List, Optional, Union, Dict, Any # Configure logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') def calculate_accuracy(predictions: List[Optional[List[str]]], ground_truths: List[List[str]]) -> float: """ Calculates the accuracy of LLM predictions against ground truths. Accuracy is defined as the percentage of predictions where the predicted list of answer strings exactly matches the ground truth list of answer strings (order within the list does not matter, comparison is case-insensitive). A prediction of None (due to parsing failure) is considered incorrect. Args: predictions (List[Optional[List[str]]]): A list where each element is either a list of predicted answer strings or None if parsing failed for that question. ground_truths (List[List[str]]): A list where each element is a list of ground truth answer strings. Returns: float: The calculated accuracy (between 0.0 and 1.0). Raises: ValueError: If the lengths of predictions and ground_truths lists do not match. """ if len(predictions) != len(ground_truths): raise ValueError(f"Length mismatch: Predictions ({len(predictions)}) vs Ground Truths ({len(ground_truths)})") if not ground_truths: return 0.0 # Avoid division by zero if the list is empty correct_count = 0 for i, pred_list_orig in enumerate(predictions): truth_list_orig = ground_truths[i] # Convert to uppercase and sort for case-insensitive, order-independent comparison # Handle None case for prediction # Ensure elements are strings before calling upper() sorted_pred = sorted([str(p).upper() for p in pred_list_orig]) if pred_list_orig is not None else None sorted_truth = sorted([str(t).upper() for t in truth_list_orig]) if sorted_pred is not None and sorted_pred == sorted_truth: correct_count += 1 else: # Log incorrect only if prediction was not None (parsing succeeded but answer wrong) if sorted_pred is not None: logging.debug(f"Incorrect prediction for index {i}: Pred={sorted_pred}, Truth={sorted_truth} (Original Pred: {pred_list_orig}, Original Truth: {truth_list_orig})") # If sorted_pred is None, it means parsing failed or API failed, already counted as incorrect implicitly accuracy = correct_count / len(ground_truths) logging.info(f"Accuracy calculated: {correct_count}/{len(ground_truths)} = {accuracy:.4f}") return accuracy def get_subject_as_section(subject: str, question_num_for_log: int) -> Optional[str]: """ Returns the subject name directly as the section identifier. question_num_for_log is only used for logging context if subject is invalid. """ if subject and isinstance(subject, str) and subject.strip(): return subject.strip() else: logging.warning(f"Invalid or missing subject ('{subject}') for question_num '{question_num_for_log}'. Cannot determine section.") return None def is_within_range(predicted_value_str: str, lower_bound_str: str, upper_bound_str: str) -> bool: """ Checks if a predicted numerical value (as a string) falls within a specified range. The comparison is inclusive. """ try: predicted_value = float(predicted_value_str) lower_bound = float(lower_bound_str) upper_bound = float(upper_bound_str) except ValueError: logging.debug(f"Could not convert predicted value '{predicted_value_str}' or bounds ('{lower_bound_str}', '{upper_bound_str}') to numbers.") return False return lower_bound <= predicted_value <= upper_bound def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict[str, Any]: """ Calculates marks_awarded and evaluation_status for a single question result. Args: result_item (Dict[str, Any]): A dictionary for a single question, must contain: 'question_id' (str) 'exam_name' (str) 'question_type' (str) 'ground_truth' (List[str] | str) # Changed to string 'predicted_answer' (List[str] | str | None) # Changed to string 'api_call_successful' (bool) Returns: Dict[str, Any]: A dictionary with 'marks_awarded' (int) and 'evaluation_status' (str). """ question_id = result_item.get("question_id", "UNKNOWN_QID") # Provide default for logging exam_name = result_item.get("exam_name", "").upper() question_type = result_item.get("question_type", "").upper() pred = result_item.get("predicted_answer") truth = result_item.get("ground_truth") api_success = result_item.get("api_call_successful", False) current_score_change = 0 evaluation_status = "unknown" # Ensure truth is a set of uppercase strings for consistent processing. # Ground truth from metadata.jsonl is expected to be a list of strings. # e.g., ["1"], ["A"], ["12.75"], ["A", "C"] # For integer ranges, it will be like [["0.7", "0.8"]] truth_processed: List[Union[str, List[str]]] = [] if isinstance(truth, list): for t_item in truth: if isinstance(t_item, str): truth_processed.append(t_item.upper()) elif isinstance(t_item, list) and len(t_item) == 2 and all(isinstance(x, str) for x in t_item): truth_processed.append([x.upper() for x in t_item]) # Store range as list of uppercase strings else: logging.error(f"Invalid item in ground_truth list for {question_id}: {t_item}. Skipping.") elif isinstance(truth, str): truth_processed.append(truth.upper()) else: logging.error(f"Invalid ground_truth format for {question_id}: {truth} (type: {type(truth)}). Assigning 0 marks.") return {"marks_awarded": 0, "evaluation_status": "error_bad_ground_truth"} if not api_success or pred is None: # pred is None means our internal parsing failed evaluation_status = "failure_api_or_parse" 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 isinstance(pred, str) and pred.upper() == "SKIP": # Standardize SKIP comparison current_score_change = 0 evaluation_status = "skipped" elif isinstance(pred, list) and all(isinstance(p, str) for p in pred): pred_set = {p.upper() for p in pred} # Convert to uppercase strings # Handle MCQ_SINGLE_CORRECT first, as it has special logic for multiple truths. # The parser (`parse_llm_answer`) returns `pred` as `list[str]` with one element for valid single answers. if question_type == "MCQ_SINGLE_CORRECT": # A prediction is correct if its single element is present in the truth_set. # This accommodates metadata entries where `correct_answer` for an MCQ_SINGLE_CORRECT # might list multiple acceptable options (e.g., if a question had two official correct answers). is_correct = False if len(pred_set) == 1: # Ensure prediction is indeed a single option single_pred_answer = list(pred_set)[0] # Get the single predicted option # Check against all processed truths (which are single strings for MCQ) if single_pred_answer in truth_processed: is_correct = True if is_correct: evaluation_status = "correct" if exam_name == "NEET": current_score_change = 4 elif exam_name == "JEE_MAIN": current_score_change = 4 elif exam_name == "JEE_ADVANCED": current_score_change = 3 else: current_score_change = 1 # Default positive score for unknown exam else: evaluation_status = "incorrect" if exam_name == "NEET": current_score_change = -1 elif exam_name == "JEE_MAIN": current_score_change = -1 elif exam_name == "JEE_ADVANCED": current_score_change = -1 else: current_score_change = 0 # Default no penalty elif exam_name == "JEE_MAIN" and question_type == "INTEGER": # Integer answers are now strings in a list e.g. ["14"] # For JEE_MAIN INTEGER, we expect truth_processed to contain single strings is_correct = False if len(pred_set) == 1: predicted_answer_str = list(pred_set)[0] if predicted_answer_str in truth_processed: # Check against single string truths is_correct = True if is_correct: current_score_change = 4; evaluation_status = "correct" else: current_score_change = 0; evaluation_status = "incorrect" elif exam_name == "JEE_ADVANCED": # Note: MCQ_SINGLE_CORRECT for JEE_ADVANCED is handled by the common block above if question_type == "INTEGER": is_correct = False if len(pred_set) == 1: predicted_answer_str = list(pred_set)[0] # Get the single predicted string # Iterate through each ground truth entry in the 'truth_processed' list for gt_entry in truth_processed: if isinstance(gt_entry, list) and len(gt_entry) == 2: # This is a range [lower, upper] lower_bound_str, upper_bound_str = gt_entry[0], gt_entry[1] if is_within_range(predicted_answer_str, lower_bound_str, upper_bound_str): is_correct = True break # Found a matching range, no need to check others elif isinstance(gt_entry, str): # This is an exact integer match if predicted_answer_str == gt_entry: # gt_entry is already uppercase is_correct = True break # Found an exact match, no need to check others if is_correct: current_score_change = 4; evaluation_status = "correct" else: current_score_change = 0; evaluation_status = "incorrect" elif question_type == "MCQ_MULTIPLE_CORRECT": # For MCQ_MULTIPLE_CORRECT, truth_processed contains single strings truth_set_mcq = set(truth_processed) # Convert to set for intersection operations num_correct_options_in_truth = len(truth_set_mcq) num_chosen_options = len(pred_set) correct_chosen_options = pred_set.intersection(truth_set_mcq) incorrect_chosen_options = pred_set.difference(truth_set_mcq) num_correct_chosen = len(correct_chosen_options) num_incorrect_chosen = len(incorrect_chosen_options) if num_incorrect_chosen > 0: current_score_change = -2; evaluation_status = "incorrect_negative" elif num_correct_chosen == num_correct_options_in_truth and num_chosen_options == num_correct_options_in_truth: current_score_change = 4; evaluation_status = "correct_full" elif num_correct_options_in_truth == 4 and num_correct_chosen == 3 and num_chosen_options == 3: current_score_change = 3; evaluation_status = "partial_3_of_4" elif num_correct_options_in_truth >= 3 and num_correct_chosen == 2 and num_chosen_options == 2: current_score_change = 2; evaluation_status = "partial_2_of_3_plus" elif num_correct_options_in_truth >= 2 and num_correct_chosen == 1 and num_chosen_options == 1: current_score_change = 1; evaluation_status = "partial_1_of_2_plus" else: current_score_change = 0; evaluation_status = "no_marks_no_penalty" else: 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: logging.error(f"Unexpected prediction type for {question_id}: {pred}. Treating as API/Parse Failure.") current_score_change = -1 # Default penalty evaluation_status = "failure_unexpected_type" return {"marks_awarded": current_score_change, "evaluation_status": evaluation_status} def calculate_max_score_for_question(exam_name: str, question_type: str) -> int: """ Returns the maximum possible score for a given exam and question type. """ exam_name = exam_name.upper() question_type = question_type.upper() if exam_name == "NEET" and question_type == "MCQ_SINGLE_CORRECT": return 4 elif exam_name == "JEE_MAIN": if question_type == "MCQ_SINGLE_CORRECT": return 4 elif question_type == "INTEGER": return 4 elif exam_name == "JEE_ADVANCED": if question_type == "MCQ_SINGLE_CORRECT": return 3 elif question_type == "INTEGER": return 4 elif question_type == "MCQ_MULTIPLE_CORRECT": return 4 # Max score for multiple correct is 4 return 0 # Default for unknown types def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]: """ Calculates exam scores based on exam_name and question_type, providing section-wise breakdown and detailed question type statistics. Args: results (List[Dict[str, Any]]): A list of result dictionaries. Each dict must contain: '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[str] | str): Correct answer(s). For INTEGER, it's a single str. 'predicted_answer' (List[str] | 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' by calling calculate_single_question_score_details for each item. Returns: Dict[str, Any]: A dictionary containing overall and section-wise scores and counts, plus question type breakdowns and total possible score. """ if not results: return {"error": "No results provided."} overall_stats = { "score": 0, "correct": 0, "incorrect": 0, "skipped": 0, "api_parse_failures": 0, "partial_correct": 0, "total_possible_score": 0 # New field } # Initialize question type breakdown question_type_breakdown: Dict[str, Dict[str, Any]] = {} 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: 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, "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.") unmapped_section_questions = 0 for result in results: question_id = result.get("question_id") # For logging within loop subject = result.get("subject") # For section mapping exam_name = result.get("exam_name", "").upper() question_type = result.get("question_type", "").upper() # Calculate score details for the single question score_details = calculate_single_question_score_details(result) current_score_change = score_details.get("marks_awarded", 0) evaluation_status = score_details.get("evaluation_status", "unknown_error_in_scoring") # Update the result dictionary in-place (as original function did) result['evaluation_status'] = evaluation_status result['marks_awarded'] = current_score_change # Accumulate total possible score overall_stats["total_possible_score"] += calculate_max_score_for_question(exam_name, question_type) # Determine boolean flags based on evaluation_status for aggregation is_correct_full = evaluation_status in ["correct", "correct_full"] is_partial_correct = evaluation_status.startswith("partial_") is_incorrect_choice = evaluation_status in ["incorrect", "incorrect_negative"] is_skipped = evaluation_status == "skipped" is_api_parse_failure = evaluation_status in ["failure_api_or_parse", "failure_unexpected_type", "error_bad_ground_truth"] overall_stats["score"] += current_score_change if is_correct_full: overall_stats["correct"] += 1 if is_incorrect_choice: overall_stats["incorrect"] += 1 if is_skipped: overall_stats["skipped"] += 1 if is_api_parse_failure: overall_stats["api_parse_failures"] += 1 if is_partial_correct: overall_stats["partial_correct"] +=1 # Aggregate by question type if question_type not in question_type_breakdown: question_type_breakdown[question_type] = { "count": 0, "score": 0, "correct_full": 0, "partial_correct": 0, "incorrect_choice": 0, "skipped": 0, "api_parse_failures": 0, "max_score_per_question": calculate_max_score_for_question(exam_name, question_type) } q_type_stats = question_type_breakdown[question_type] q_type_stats["count"] += 1 q_type_stats["score"] += current_score_change if is_correct_full: q_type_stats["correct_full"] += 1 if is_incorrect_choice: q_type_stats["incorrect_choice"] += 1 if is_skipped: q_type_stats["skipped"] += 1 if is_api_parse_failure: q_type_stats["api_parse_failures"] += 1 if is_partial_correct: q_type_stats["partial_correct"] += 1 section = None if subject: question_num_for_log = -1 # Placeholder, as QID might not have number if question_id: match_num = re.search(r'_(\d+)$', question_id) if match_num: try: question_num_for_log = int(match_num.group(1)) except ValueError: pass section = get_subject_as_section(subject, question_num_for_log) if section and section in section_stats: section_stats[section]["score"] += current_score_change 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 if is_api_parse_failure: section_stats[section]["api_parse_failures"] += 1 if is_partial_correct: section_stats[section]["partial_correct"] +=1 elif section is None and not is_api_parse_failure : # only count as unmapped if not already an API/parse failure (which might lack subject) unmapped_section_questions += 1 # logging.warning(f"Could not map question to section: ID={question_id}, Subject={subject}") # Already logged by get_subject_as_section if subject is bad 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_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), "total_possible_score_for_processed_questions": overall_stats["total_possible_score"], # New field "unmapped_section_questions": unmapped_section_questions, "section_breakdown": section_stats, "question_type_breakdown": question_type_breakdown # New field } # Example Usage (for testing) if __name__ == '__main__': print("Running evaluation tests...") # --- Test calculate_accuracy (now with strings) --- print("\n--- Testing calculate_accuracy ---") preds1_str = [["1"], ["2"], ["1", "3"]] truths1_str = [["1"], ["2"], ["3", "1"]] acc1_str = calculate_accuracy(preds1_str, truths1_str) print(f"Test Case 1 (Accuracy - String): Preds={preds1_str}, Truths={truths1_str} -> Accuracy: {acc1_str} (Expected: 1.0)") assert acc1_str == 1.0 preds2_str = [["A"], ["B"], ["A", "C"]] truths2_str = [["a"], ["b"], ["c", "a"]] # Test case-insensitivity acc2_str = calculate_accuracy(preds2_str, truths2_str) print(f"Test Case 2 (Accuracy - String Case-Insensitive): Preds={preds2_str}, Truths={truths2_str} -> Accuracy: {acc2_str} (Expected: 1.0)") assert acc2_str == 1.0 preds3_str = [["10"], None, ["5"]] truths3_str = [["10"], ["7"], ["5"]] acc3_str = calculate_accuracy(preds3_str, truths3_str) print(f"Test Case 3 (Accuracy - String with None): Preds={preds3_str}, Truths={truths3_str} -> Accuracy: {acc3_str} (Expected: {2/3})") assert acc3_str == (2/3) # --- Test calculate_exam_scores (now with strings) --- print("\n--- Testing calculate_exam_scores ---") test_results_exam = [ # NEET - Answers as strings "1", "2", "A", "B" etc. {"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": ["D"], "predicted_answer": ["B"], "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": ["C"], "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": ["A"], "predicted_answer": None, "api_call_successful": True}, # Parse Fail -1 # JEE Main - MCQ - Answers as strings "1", "2", "A", "B" etc. {"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": ["C"], "predicted_answer": ["a"], "api_call_successful": True}, # Incorrect -1 (C vs a) # JEE Main - Integer - Answers as strings e.g., "5", "10" {"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 - Answers as strings "A", "B" etc. {"question_id": "JA001", "subject": "Maths", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": ["A"], "predicted_answer": ["a"], "api_call_successful": True}, # Correct +3 (case-insensitive) {"question_id": "JA002", "subject": "Maths", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_SINGLE_CORRECT", "ground_truth": ["B"], "predicted_answer": ["C"], "api_call_successful": True}, # Incorrect -1 # JEE Advanced - Integer - Answers as strings e.g., "12", "0" {"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 - Answers as strings "A", "C" etc. {"question_id": "JA005", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": ["A", "C"], "predicted_answer": ["a", "c"], "api_call_successful": True}, # All Correct +4 {"question_id": "JA006", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": ["A", "B", "C"], "predicted_answer": ["a", "b"], "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": ["A", "B", "C", "D"], "predicted_answer": ["a", "b", "c"], "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": ["A", "B"], "predicted_answer": ["a"], "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": ["A", "C"], "predicted_answer": ["a", "b"], "api_call_successful": True}, # Incorrect option chosen -2 {"question_id": "JA010", "subject": "Chemistry", "exam_name": "JEE_ADVANCED", "question_type": "MCQ_MULTIPLE_CORRECT", "ground_truth": ["A", "C"], "predicted_answer": ["b", "d"], "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": ["A", "C"], "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": ["A"], "predicted_answer": ["a"], "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": ["A","B","C"], "predicted_answer": ["a","d"], "api_call_successful": True}, # One correct, one incorrect -> -2 ] exam_summary = calculate_exam_scores(test_results_exam) print("\nExam Score Summary:") import json 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.")