class_docstr: Base class for various task test suites.
  
  This is a wrapper class around the CheckList toolkit introduced
  in the paper
  [Beyond Accuracy: Behavioral Testing of NLP models with CheckList (Ribeiro et al)]
  (https://api.semanticscholar.org/CorpusID:218551201).
  
  !!! Note
      To use the checklist integration you should install ``allennlp`` with the
      "checklist" extra (e.g. ``conda install allennlp-checklist``,
      ``pip install allennlp[checklist]`` or just install `checklist` after the fact).
  
  Task suites are intended to be used as a form of behavioral testing
  for NLP models to check for robustness across several general linguistic
  capabilities; eg. Vocabulary, SRL, Negation, etc.
  
  An example of the entire checklist process can be found at:
  [https://github.com/marcotcr/checklist/blob/master/notebooks/tutorials/]
  (https://github.com/marcotcr/checklist/blob/master/notebooks/tutorials/).
  
  A task suite should contain tests that check general capabilities, including
  but not limited to:
  
  * Vocabulary + POS : Important words/word types for the task
  * Taxonomy : Synonyms/antonyms, etc.
  * Robustness : To typos, irrelevant changes, etc.
  * NER : Appropriately understanding named entities.
  * Temporal : Understanding the order of events.
  * Negation
  * Coreference
  * Semantic Role Labeling : Understanding roles such as agents and objects.
  * Logic : Ability to handle symmetry, consistency, and conjunctions.
  * Fairness
  
  
  # Parameters
  
  suite: `checklist.test_suite.TestSuite`, optional (default = `None`)
      Pass in an existing test suite.
  
  add_default_tests: `bool` (default = `False`)
      Whether to add default checklist tests for the task.
  
  data: `List[Any]`, optional (default = `None`)
      If the data is provided, and `add_default_tests` is `True`,
      tests that perturb the data are also added.
  
      For instance, if the task is sentiment analysis, and the a
      list of sentences is passed, it will add tests that check
      a model's robustness to typos, etc.
docstr: Internal function for description and summary.
docstr_tok: ["Internal","function","for","description","and","summary","."]
code: def _summary(
      self,
      overview_only: bool = False,
      capabilities: Optional[List[str]] = None,
      **kwargs,
  ):
      """
      Internal function for description and summary.
      """
  
      # The capabilities are sorted such that if the capability does not exist
      # in the list of pre-defined `_capabilities`, then it is put at the end.
      # `100` is selected as an arbitrary large number; we do not expect the
      # number of capabilities to be higher.
      def cap_order(x):
          return (
              self._capabilities.index(x)
              if x in self._capabilities
              else 100
          )
  
      capabilities = capabilities or sorted(
          set([x["capability"] for x in self.suite.info.values()]),
          key=cap_order,
      )
      print(
          "\n\nThis suite contains {} tests across {} capabilities.".format(
              len(self.suite.tests), len(capabilities)
          )
      )
      print()
      for capability in capabilities:
          tests = [
              name
              for name, test in self.suite.info.items()
              if test["capability"] == capability
          ]
          num_tests = len(tests)
          if num_tests > 0:
              print(
                  f'\nCapability: "{capability}" ({num_tests} tests)\n'
              )
              for test in tests:
                  description = self.suite.info[test]["description"]
                  num_test_cases = len(self.suite.tests[test].data)
                  about_test = (
                      f"* Name: {test} ({num_test_cases} test cases)"
                  )
                  if description:
                      about_test += f"\n{description}"
                  print(about_test)
  
                  if not overview_only:
                      if "format_example_fn" not in kwargs:
                          kwargs["format_example_fn"] = self.suite.info[
                              test
                          ].get(
                              "format_example_fn",
                              self._format_failing_examples,
                          )
                      if "print_fn" not in kwargs:
                          kwargs["print_fn"] = self.suite.info[
                              test
                          ].get("print_fn", self.suite.print_fn)
                      print()
                      self.suite.tests[test].summary(**kwargs)
                      print()
  
imports: import sys
  import logging
  from typing import Type, Optional, Dict, Any, Callable, List, Iterable, Union, TextIO, Tuple
  import numpy
  from checklist.test_suite import TestSuite
  from checklist.editor import Editor
  from checklist.test_types import MFT, INV, DIR
  from checklist.perturb import Perturb
  from allennlp.common.registrable import Registrable
  from allennlp.common.file_utils import cached_path
  from allennlp.predictors.predictor import Predictor
  from allennlp.confidence_checks.task_checklists import utils
label_desc: Use image node_id 5 for calling the TaskSuite obj's underlying member method code with example usage: obj._summary(overview_only, capabilities) and returns: unknown