class_docstr: An object that stores necessary information for saving and loading
  checkpoints.
  
  Args:
      attack_args (textattack.AttackArgs): Arguments of the original attack
      attack_log_manager (textattack.loggers.AttackLogManager): Object for storing attack results
      worklist (deque[int]): List of examples that will be attacked. Examples are represented by their indicies within the dataset.
      worklist_candidates (int): List of other available examples we can attack. Used to get the next dataset element when `attack_n=True`.
      chkpt_time (float): epoch time representing when checkpoint was made
code: def __repr__(self):
      main_str = "AttackCheckpoint("
      lines = []
      lines.append(utils.add_indent(f"(Time):  {self.datetime}", 2))
  
      args_lines = []
      recipe_set = (
          True
          if "recipe" in self.attack_args.__dict__
          and self.attack_args.__dict__["recipe"]
          else False
      )
      mutually_exclusive_args = [
          "search",
          "transformation",
          "constraints",
          "recipe",
      ]
      if recipe_set:
          args_lines.append(
              utils.add_indent(
                  f'(recipe): {self.attack_args.__dict__["recipe"]}', 2
              )
          )
      else:
          args_lines.append(
              utils.add_indent(
                  f'(search): {self.attack_args.__dict__["search"]}', 2
              )
          )
          args_lines.append(
              utils.add_indent(
                  f'(transformation): {self.attack_args.__dict__["transformation"]}',
                  2,
              )
          )
          args_lines.append(
              utils.add_indent(
                  f'(constraints): {self.attack_args.__dict__["constraints"]}',
                  2,
              )
          )
  
      for key in self.attack_args.__dict__:
          if key not in mutually_exclusive_args:
              args_lines.append(
                  utils.add_indent(
                      f"({key}): {self.attack_args.__dict__[key]}", 2
                  )
              )
  
      args_str = utils.add_indent("\n" + "\n".join(args_lines), 2)
      lines.append(utils.add_indent(f"(attack_args):  {args_str}", 2))
  
      attack_logger_lines = []
      attack_logger_lines.append(
          utils.add_indent(
              f"(Total number of examples to attack): {self.attack_args.num_examples}",
              2,
          )
      )
      attack_logger_lines.append(
          utils.add_indent(
              f"(Number of attacks performed): {self.results_count}", 2
          )
      )
      attack_logger_lines.append(
          utils.add_indent(
              f"(Number of remaining attacks): {self.num_remaining_attacks}",
              2,
          )
      )
      breakdown_lines = []
      breakdown_lines.append(
          utils.add_indent(
              f"(Number of successful attacks): {self.num_successful_attacks}",
              2,
          )
      )
      breakdown_lines.append(
          utils.add_indent(
              f"(Number of failed attacks): {self.num_failed_attacks}",
              2,
          )
      )
      breakdown_lines.append(
          utils.add_indent(
              f"(Number of maximized attacks): {self.num_maximized_attacks}",
              2,
          )
      )
      breakdown_lines.append(
          utils.add_indent(
              f"(Number of skipped attacks): {self.num_skipped_attacks}",
              2,
          )
      )
      breakdown_str = utils.add_indent(
          "\n" + "\n".join(breakdown_lines), 2
      )
      attack_logger_lines.append(
          utils.add_indent(
              f"(Latest result breakdown): {breakdown_str}", 2
          )
      )
      attack_logger_str = utils.add_indent(
          "\n" + "\n".join(attack_logger_lines), 2
      )
      lines.append(
          utils.add_indent(
              f"(Previous attack summary):  {attack_logger_str}", 2
          )
      )
  
      main_str += "\n  " + "\n  ".join(lines) + "\n"
      main_str += ")"
      return main_str
  
imports: import copy
  import datetime
  import os
  import pickle
  import time
  import textattack
  from textattack.attack_results import FailedAttackResult, MaximizedAttackResult, SkippedAttackResult, SuccessfulAttackResult
  from textattack.shared import logger, utils
label_desc: Use image node_id 2 for calling the AttackCheckpoint obj's underlying member method code with example usage: obj.__repr__() and returns: main_str