fix linting (#842)

Author: pbcong

lmms_eval/tasks/lemonade/utils.py

@@ -1,14 +1,15 @@
 import ast
 import os
-import cv2
-import numpy as np
 import zipfile
-import yaml
 from collections import defaultdict
 from pathlib import Path
-from PIL import Image
 from typing import Any, Optional
+
+import cv2
+import numpy as np
+import yaml
 from huggingface_hub import hf_hub_download
+from PIL import Image
 
 with open(Path(__file__).parent / "lemonade.yaml", "r") as f:
     raw_data = f.readlines()
@@ -39,7 +40,7 @@ def load_video(video_file: str, start_frame: int, end_frame: int, max_num_frames
     """
 
     cap = cv2.VideoCapture(video_file)
-    try: 
+    try:
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         start_frame = max(0, start_frame)
         end_frame = min(end_frame, total_frames - 1)
@@ -61,11 +62,12 @@ def load_video(video_file: str, start_frame: int, end_frame: int, max_num_frames
     finally:
         cap.release()
 
+
 def parse_options(options: list[str]) -> str:
     """
     Format a list of multiple-choice options into a string.
-    The function assigns letters to each option and returns them in a newline-separated string.    
-    
+    The function assigns letters to each option and returns them in a newline-separated string.
+
     Args:
         options (list[str]): A list of option strings.
 
@@ -100,12 +102,9 @@ def lemonade_doc_to_visual(doc: dict[str, Any]) -> list[Image.Image]:
         end = int(doc["End"])
         frames = load_video(video_path, start, end, max_num_frames=max_num_frames)
     else:
-        raise FileNotFoundError(
-            f"Video file not found: {video_path}. "
-            f"Expected video for clip '{doc['Clip']}' at {video_path}"
-        )
+        raise FileNotFoundError(f"Video file not found: {video_path}. " f"Expected video for clip '{doc['Clip']}' at {video_path}")
     return frames
-    
+
 
 def lemonade_doc_to_text(doc: dict[str, Any], lmms_eval_specific_kwargs: Optional[dict[str, Any]] = None) -> str:
     """
@@ -119,10 +118,10 @@ def lemonade_doc_to_text(doc: dict[str, Any], lmms_eval_specific_kwargs: Optiona
 
     if lmms_eval_specific_kwargs is None:
         lmms_eval_specific_kwargs = {}
-        
+
     pre_prompt = lmms_eval_specific_kwargs.get("pre_prompt", "")
     post_prompt = lmms_eval_specific_kwargs.get("post_prompt", "")
-    
+
     question = "Question: " + doc["Question"]
     parsed_options = parse_options(ast.literal_eval(doc["Answers"]))
     choices = "Choices:\n" + parsed_options
@@ -133,18 +132,18 @@ def lemonade_doc_to_text(doc: dict[str, Any], lmms_eval_specific_kwargs: Optiona
 def get_multi_choice_info(options: list[str]) -> tuple[dict[str, str], list[str]]:
     """
     Map a list of options to letter labels (A, B, C, ...).
-    
+
     Args:
         options: The set of answer options
     Returns:
-        tuple[dict[str, str], list[str]]: 
+        tuple[dict[str, str], list[str]]:
             - index2ans: Mapping from letters to option text.
             - all_choices: List of the assigned letters.
     """
-    
+
     if not isinstance(options, list):
         raise TypeError(f"Expected list of options, got {type(options)}: {options}")
-   
+
     start_chr = "A"
     all_choices = []
     index2ans = {}
@@ -157,7 +156,7 @@ def get_multi_choice_info(options: list[str]) -> tuple[dict[str, str], list[str]
 
 def parse_multi_choice_response(response: str, all_choices: list[str], index2ans: dict[str, str]) -> str:
     """
-    Parse a model response and return the predicted choice label (e.g., "A", "B", "C", "D"). 
+    Parse a model response and return the predicted choice label (e.g., "A", "B", "C", "D").
 
     Args:
         response (str): The generated response to parse.
@@ -175,7 +174,7 @@ def parse_multi_choice_response(response: str, all_choices: list[str], index2ans
 
     for char in [",", ".", "!", "?", ";", ":", "'"]:
         response = response.strip(char)
-    response = " " + response + " " 
+    response = " " + response + " "
 
     index_ans = True
     ans_with_brack = False
@@ -187,7 +186,7 @@ def parse_multi_choice_response(response: str, all_choices: list[str], index2ans
         if f"{choice}." in response:
             candidates.append(choice)
             ans_with_period = True
-    for choice in all_choices: 
+    for choice in all_choices:
         if f"{choice}:" in response:
             candidates.append(choice)
             ans_with_colon = True
@@ -197,14 +196,14 @@ def parse_multi_choice_response(response: str, all_choices: list[str], index2ans
                 candidates.append(choice)
                 ans_with_brack = True
     if len(candidates) == 0:
-        for choice in all_choices: 
+        for choice in all_choices:
             if f"{choice} " in response:
                 candidates.append(choice)
     if len(candidates) == 0 and len(response.split()) > 5:
         for index, ans in index2ans.items():
             if ans.lower() in response.lower():
                 candidates.append(index)
-                index_ans = False 
+                index_ans = False
     if len(candidates) == 0:
         pred_index = "A"
 
@@ -241,40 +240,33 @@ def parse_multi_choice_response(response: str, all_choices: list[str], index2ans
 def lemonade_process_results(doc: dict[str, Any], results: list[Any]) -> dict[str, dict]:
     """
     Process the results from the model and compute accuracy.
-    
+
     Args:
         doc: A dictionary representing an entry in the dataset.
         results: List of model outputs.
     Returns:
-        A dictionary containing accuracy information. 
+        A dictionary containing accuracy information.
     """
-    
+
     pred = results[0]
     index2ans, all_choices = get_multi_choice_info(ast.literal_eval(doc["Answers"]))
     parsed_pred = parse_multi_choice_response(pred, all_choices, index2ans)
 
-    acc = {
-        "QID": doc["QID"],
-        "category": doc["Category"],
-        "subcategory": doc["Subcategory"],
-        "difficulty": doc["Difficulty"],
-        "answer": doc["Correct Answer"],
-        "parsed_pred": parsed_pred,
-        "original_pred": pred
-    }    
+    acc = {"QID": doc["QID"], "category": doc["Category"], "subcategory": doc["Subcategory"], "difficulty": doc["Difficulty"], "answer": doc["Correct Answer"], "parsed_pred": parsed_pred, "original_pred": pred}
     return {"acc": acc}
 
 
 def lemonade_aggregate_results(results: list[dict[str, Any]]) -> float:
     """
     Aggregate the results from the evaluation.
-    
+
     Args:
         results: List of dicts containing individual evaluation results.
     Returns:
         overall_acc: Overall accuracy.
 
     """
+
     def compute_accuracy(grouped_results):
         acc_dict = {}
         for key, samples in grouped_results.items():