class_docstr: Target tests created in TargetsMeta apply to any test case with targets being a
  list or tensor.
  Attribution of each example is computed independently with the appropriate target
  and compared to the corresponding result of attributing to a batch with a tensor
  / list of targets.
code: def __new__(cls, name: str, bases: Tuple, attrs: Dict):
      for test_config in config:
          (
              algorithms,
              model,
              args,
              layer,
              noise_tunnel,
              baseline_distr,
          ) = parse_test_config(test_config)
          target_delta = (
              test_config["target_delta"]
              if "target_delta" in test_config
              else 0.0001
          )
  
          if "target" not in args or not isinstance(
              args["target"], (list, Tensor)
          ):
              continue
  
          for algorithm in algorithms:
              # FeaturePermutation requires a batch of inputs
              # so skipping tests
              if issubclass(
                  algorithm, FeaturePermutation
              ) or not should_create_generated_test(algorithm):
                  continue
              test_method = cls.make_single_target_test(
                  algorithm,
                  model,
                  layer,
                  args,
                  target_delta,
                  noise_tunnel,
                  baseline_distr,
              )
              test_name = gen_test_name(
                  "test_target",
                  cast(str, test_config["name"]),
                  algorithm,
                  noise_tunnel,
              )
  
              if test_name in attrs:
                  raise AssertionError(
                      "Trying to overwrite existing test with name: %r"
                      % test_name
                  )
              attrs[test_name] = test_method
      return super(TargetsMeta, cls).__new__(cls, name, bases, attrs)
  
imports: from typing import Any, Callable, cast, Dict, Optional, Tuple, Type
  import torch
  from captum._utils.common import _format_additional_forward_args
  from captum.attr._core.feature_permutation import FeaturePermutation
  from captum.attr._core.integrated_gradients import IntegratedGradients
  from captum.attr._core.lime import Lime
  from captum.attr._core.noise_tunnel import NoiseTunnel
  from captum.attr._utils.attribution import Attribution, InternalAttribution
  from tests.attr.helpers.gen_test_utils import gen_test_name, get_target_layer, parse_test_config, should_create_generated_test
  from tests.attr.helpers.test_config import config
  from tests.helpers.basic import assertTensorTuplesAlmostEqual, BaseTest, deep_copy_args
  from tests.helpers.basic_models import BasicModel_MultiLayer
  from torch import Tensor
  from torch.nn import Module
label_desc: Use image node_id 1 for calling the TargetsMeta obj's underlying member method code with example usage: obj.__new__(cls, name, bases, attrs) and returns: super