code: def prepare_integration_tests(opt: Opt):
      logging.info(
          "[ Preparing data for adversarial human evaluation ... ]"
      )
  
      _check_log_dir(opt["log_folder"])
      wrapper_name = opt["wrapper"]
      wrapper = load_wrapper_module(wrapper_name)()
      safety_setting = opt["safety_setting"]
  
      if safety_setting == "adversarial":
          task_name = "bot_adversarial_dialogue:HumanSafetyEvaluation"
          task_specific_opt = {
              "flatten_dialogue": True,
              "datatype": "valid",
              "bad_include_persona": False,
          }
      else:
          task_name = (
              "bot_adversarial_dialogue:HumanNonadvSafetyEvaluation"
          )
          task_specific_opt = {"datatype": "valid"}
  
      # Collect model responses to task
      (
          teacher_acts,
          model_responses,
      ) = collect_task_data_and_model_response(
          wrapper,
          opt=opt,
          task_name=task_name,
          task_specific_opt=task_specific_opt,
          save_teacher_acts=True,
      )
  
      # Format the way it is required for human evaluations
      chat_logs = []
      for inp_act, resp in zip(teacher_acts, model_responses):
          episode = []
          inp = inp_act["text"]
          inp_split = inp.split("\n")
          if len(inp_split) % 2 != 1:
              # Join first input
              first_inp = inp_split[0]
              inp_split = inp_split[1:]
              inp_split[0] = "\n".join([inp_split[0], first_inp])
          inp_split.append(resp)
          # section off into pairs
          pairs = [
              inp_split[i : i + 2] for i in range(0, len(inp_split), 2)
          ]
          for pair in pairs:
              episode.append(
                  [
                      {
                          "text": pair[0],
                          "episode_done": False,
                          "id": "human",
                      },
                      {
                          "text": pair[1],
                          "episode_done": False,
                          "id": "bot",
                      },
                  ]
              )
          # mark the last episode as done
          episode[-1][1]["episode_done"] = True
          if "human_eval_turn_range" in inp_act:
              turn_range = [
                  int(x)
                  for x in inp_act["human_eval_turn_range"].split("|")
              ]
              episode = episode[turn_range[0] : turn_range[1] + 1]
  
          chat_logs.append(episode)
  
      task_data_path = os.path.join(
          opt["log_folder"], "task_data.jsonl"
      )
      indices_path = os.path.join(
          opt["log_folder"], "annotation_indices.jsonl"
      )
      with PathManager.open(task_data_path, "w") as fw:
          for episode in chat_logs:
              fw.write(json.dumps(episode) + "\n")
      with PathManager.open(indices_path, "w") as fw:
          for episode in chat_logs:
              fw.write(f"[{len(episode) * 2 -1}]" + "\n")
  
      _next_steps(safety_setting, task_data_path, indices_path)
  
file_path: ParlAI/projects/safety_bench/prepare_integration_tests.py
imports: from parlai.core.opt import Opt
  from parlai.core.params import ParlaiParser
  from parlai.core.script import ParlaiScript
  import parlai.utils.logging
  from parlai.utils.io import PathManager
  from projects.safety_bench.utils.wrapper_loading import load_wrapper_module, setup_wrapper_registry, register_model_wrapper, MODEL_WRAPPER_REGISTRY
  from projects.safety_bench.utils.safety_testing import collect_task_data_and_model_response
  from projects.safety_bench.utils.colors import color
  import os
  from typing import Optional
  import json
label_desc: Use image node_id 4 for calling a global function with example usage: prepare_integration_tests(opt) without return types