"data": {
    "messages": [
      {"role": "user", "content": "What is the core content of Newton's First Law?"},
      {"role": "assistant", "content": "Every object remains at rest, or in motion at a constant speed in a straight line, unless it is acted upon by a force"}
    ]
  }

"response": {
    "content": "Newton's First Law states: An object will remain at rest or in uniform motion in a straight line unless acted upon by an external force.",
    "reasoning_content": "The user is asking about Newton's First Law. First, I need to determine which discipline this belongs to..."
  }

 "data": {
    "messages": [
      {"role": "system", "content": "You are an intelligent assistant developed by Company A, capable of accurately answering user questions."},
      {"role": "user", "content": "Hello, could you help explain the general theory of relativity to me?"},
      {"role": "assistant", "content": "The general theory of relativity was proposed by Einstein, introducing the relationship between the gravitational field and the curvature of spacetime."},
      {"role": "user", "content": "Then what is special relativity?"},
      {"role": "assistant", "content": "When an object moves at speeds approaching the speed of light, time, space, mass, and energy all exhibit laws entirely different from everyday experience, and the speed of light is the ultimate speed limit for all objects in the universe."}
    ]
  }

"response": {
    "content": "Special relativity primarily studies the laws of motion in inertial frames, including time dilation and length contraction.",
    "reasoning_content": "The user is asking about special relativity, so the core content should be explained. Common expressions include the nature of spacetime under high-speed motion, such as time dilation and length contraction."
  }

  
def preprocess(data: dict, resp: dict, **kwargs) -> bool | int | str | float | None:    
    """
   :data: Dict, a dictionary containing the following key information:
                    - 'messages': Multi-turn chat history.
                    - 'ref_answer': (Optional) Reference answer.
                    - And all other user-defined fields
    :resp: Dict, the inference result of the LLM, containing the following:
                    - content: Model-generated response.
                    - reasoning_content: Inference process of the model-generated response (if any).
                    - tool_calls: List of tools called by the model (if any)
                    - And all other user-defined fields
    :**kwargs: Extension fields of the platform, which may not be provided during preprocessing.
    :return: Preprocessing result, which can be referenced in the jinja template for judge model evaluation.
    """
    # --- Implement your logic here. ---
    pass

  
def preprocess(data: dict, resp: dict) -> bool:
    # Check whether the model response contains reasoning_content.
    return resp['reasoning_content'] == ''

    
import re
default_cot_pairs = [('<think>', '</think>'), ('<Think>', '</Think>')]
def remove_cot(text: str, cot_pairs=None) -> str:
    if cot_pairs is None:
        cot_pairs = default_cot_pairs
    ret = text
    for t0, t1 in cot_pairs:
        ret = re.sub(f"{t0}.*?{t1}", '', ret, flags=re.DOTALL)
    return ret.strip()
 
 
def preprocess(data: dict, resp: dict) -> bool | int | str | float | None:
    field = 'clean'
    resp[field] = remove_cot(resp['content'])
    return resp[field]

    
def preprocess(data: dict, resp: dict) -> None:
    # Example: Add the content of the model response to the data
    if resp['content']:
        data['resp'] = resp['content']
    # Does not affect the evaluation judgment, and returns None.
    return None

  
def postprocess(
        judge_reqs: list[dict],
        judge_resps: list[dict],
        judge_models: list[dict],
        data: dict,
        resp: dict,
        **kwargs,
) -> bool | int | str | float | None:
    """
    :param judge_reqs: Scoring request data for the judge model.
    :param judge_resps: Inference results of the judge model.
    :param judge_models: Relevant configuration for the judge model.
    :return: performs custom postprocessing logic and returns a value of type bool | int | str | float | None for final evaluation result judgment, display, or statistics to facilitate metric calculation.
    """
    
    # --- Implement your logic here. ---
    pass

    
def postprocess(judge_reqs, judge_resps, judge_models, data, resp, **kwargs):
    scores = []
    for jr in judge_resps:
        try:
            # Assume the judge returns "The answer scores 4 points" or "Score: 4".
            content = jr['content']
            score = int(content.strip().split(" ")[-2])  # Simple example; adjust according to the actual format.
            scores.append(score)
        except:
            continue
    if scores:
        return round(sum(scores) / len(scores), 2)
    return None


def postprocess(judge_reqs, judge_resps, judge_models, data, resp, **kwargs):
    positive_count = 0
    for jr in judge_resps:
        content = jr['content']
        if "good" in content or "correct" in content or "4" in content or "5" in content:
            positive_count += 1
    return positive_count > len(judge_resps) / 2  # Return true if more than half consider it correct.

  
def postprocess(judge_reqs, judge_resps, judge_models, data, resp, **kwargs):
    # Data storage, structure transformation, and so on, can be performed here without affecting the final evaluation.
    return None