"""simple docstring"""


import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCamelCase								=    logging.get_logger(__name__)







def       UpperCAmelCase					(	)       ->   str:
     snake_case_       =      DetaConfig(
         num_queries=900		,      encoder_ffn_dim=2048		,      decoder_ffn_dim=2048		,      num_feature_levels=5		,      assign_first_stage=UpperCAmelCase		,      with_box_refine=UpperCAmelCase		,      two_stage=UpperCAmelCase		,      )

     # set labels
     snake_case_       =      91
     snake_case_       =      'huggingface/label-files'
     snake_case_       =      'coco-detection-id2label.json'
     snake_case_       =      json.load(open(cached_download(hf_hub_url(UpperCAmelCase		,      UpperCAmelCase		,      repo_type='dataset'      )      )		,      'r'      )      )
     snake_case_       =      {int(UpperCAmelCase      ): v for k, v in idalabel.items()}
     snake_case_       =      idalabel
     snake_case_       =      {v: k for k, v in idalabel.items()}

     return config







def       UpperCAmelCase					(	UpperCAmelCase      )       ->   Optional[Any]:
     snake_case_       =      []

     # stem
     # fmt: off
     rename_keys.append(('backbone.0.body.conv1.weight', 'model.backbone.model.embedder.embedder.convolution.weight')      )
     rename_keys.append(('backbone.0.body.bn1.weight', 'model.backbone.model.embedder.embedder.normalization.weight')      )
     rename_keys.append(('backbone.0.body.bn1.bias', 'model.backbone.model.embedder.embedder.normalization.bias')      )
     rename_keys.append(('backbone.0.body.bn1.running_mean', 'model.backbone.model.embedder.embedder.normalization.running_mean')      )
     rename_keys.append(('backbone.0.body.bn1.running_var', 'model.backbone.model.embedder.embedder.normalization.running_var')      )
     # stages
     for stage_idx in range(len(config.backbone_config.depths      )      ):
          for layer_idx in range(config.backbone_config.depths[stage_idx]      ):
               # shortcut
               if layer_idx == 0:
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var',
                        )      )
               # 3 convs
               for i in range(3      ):
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean',
                        )      )
                    rename_keys.append(
                        (
                            f'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var',
                            f'model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var',
                        )      )
    # transformer encoder
     for i in range(config.encoder_layers      ):
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight', f'model.encoder.layers.{i}.self_attn.sampling_offsets.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias', f'model.encoder.layers.{i}.self_attn.sampling_offsets.bias')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.weight', f'model.encoder.layers.{i}.self_attn.attention_weights.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.bias', f'model.encoder.layers.{i}.self_attn.attention_weights.bias')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.weight', f'model.encoder.layers.{i}.self_attn.value_proj.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.bias', f'model.encoder.layers.{i}.self_attn.value_proj.bias')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.weight', f'model.encoder.layers.{i}.self_attn.output_proj.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.bias', f'model.encoder.layers.{i}.self_attn.output_proj.bias')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.norm1.weight', f'model.encoder.layers.{i}.self_attn_layer_norm.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.norm1.bias', f'model.encoder.layers.{i}.self_attn_layer_norm.bias')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.linear1.weight', f'model.encoder.layers.{i}.fc1.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.linear1.bias', f'model.encoder.layers.{i}.fc1.bias')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.linear2.weight', f'model.encoder.layers.{i}.fc2.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.linear2.bias', f'model.encoder.layers.{i}.fc2.bias')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.norm2.weight', f'model.encoder.layers.{i}.final_layer_norm.weight')      )
          rename_keys.append((f'transformer.encoder.layers.{i}.norm2.bias', f'model.encoder.layers.{i}.final_layer_norm.bias')      )

     # transformer decoder
     for i in range(config.decoder_layers      ):
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.weight', f'model.decoder.layers.{i}.encoder_attn.attention_weights.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.bias', f'model.decoder.layers.{i}.encoder_attn.attention_weights.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.weight', f'model.decoder.layers.{i}.encoder_attn.value_proj.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.bias', f'model.decoder.layers.{i}.encoder_attn.value_proj.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.weight', f'model.decoder.layers.{i}.encoder_attn.output_proj.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.bias', f'model.decoder.layers.{i}.encoder_attn.output_proj.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.norm1.weight', f'model.decoder.layers.{i}.encoder_attn_layer_norm.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.norm1.bias', f'model.decoder.layers.{i}.encoder_attn_layer_norm.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.weight', f'model.decoder.layers.{i}.self_attn.out_proj.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.bias', f'model.decoder.layers.{i}.self_attn.out_proj.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.norm2.weight', f'model.decoder.layers.{i}.self_attn_layer_norm.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.norm2.bias', f'model.decoder.layers.{i}.self_attn_layer_norm.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.linear1.weight', f'model.decoder.layers.{i}.fc1.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.linear1.bias', f'model.decoder.layers.{i}.fc1.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.linear2.weight', f'model.decoder.layers.{i}.fc2.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.linear2.bias', f'model.decoder.layers.{i}.fc2.bias')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.norm3.weight', f'model.decoder.layers.{i}.final_layer_norm.weight')      )
          rename_keys.append((f'transformer.decoder.layers.{i}.norm3.bias', f'model.decoder.layers.{i}.final_layer_norm.bias')      )

     # fmt: on

     return rename_keys







def       UpperCAmelCase					(	UpperCAmelCase		,      UpperCAmelCase		,      UpperCAmelCase      )       ->   Dict:
     snake_case_       =      dct.pop(UpperCAmelCase      )
     snake_case_       =      val







def       UpperCAmelCase					(	UpperCAmelCase		,      UpperCAmelCase      )       ->   Optional[Any]:
     # transformer decoder self-attention layers
     snake_case_       =      config.d_model
     for i in range(config.decoder_layers      ):
          # read in weights + bias of input projection layer of self-attention
          snake_case_       =      state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_weight'      )
          snake_case_       =      state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_bias'      )
          # next, add query, keys and values (in that order) to the state dict
          snake_case_       =      in_proj_weight[:hidden_size, :]
          snake_case_       =      in_proj_bias[:hidden_size]
          snake_case_       =      in_proj_weight[
              hidden_size : hidden_size * 2, :
          ]
          snake_case_       =      in_proj_bias[hidden_size : hidden_size * 2]
          snake_case_       =      in_proj_weight[-hidden_size:, :]
          snake_case_       =      in_proj_bias[-hidden_size:]







def       UpperCAmelCase					(	)       ->   Tuple:
     snake_case_       =      'http://images.cocodataset.org/val2017/000000039769.jpg'
     snake_case_       =      Image.open(requests.get(UpperCAmelCase		,      stream=UpperCAmelCase      ).raw      )

     return im







@torch.no_grad()
def       UpperCAmelCase					(	UpperCAmelCase		,      UpperCAmelCase		,      UpperCAmelCase      )       ->   Optional[Any]:
     snake_case_       =      get_deta_config()

     # load original state dict
     if model_name == "deta-resnet-50":
          snake_case_       =      'adet_checkpoint0011.pth'
     elif model_name == "deta-resnet-50-24-epochs":
          snake_case_       =      'adet_2x_checkpoint0023.pth'
     else:
          raise ValueError(f'Model name {model_name} not supported'      )
     snake_case_       =      hf_hub_download(repo_id='nielsr/deta-checkpoints'		,      filename=UpperCAmelCase      )
     snake_case_       =      torch.load(UpperCAmelCase		,      map_location='cpu'      )['model']

     # rename keys
     snake_case_       =      create_rename_keys(UpperCAmelCase      )
     for src, dest in rename_keys:
          rename_key(UpperCAmelCase		,      UpperCAmelCase		,      UpperCAmelCase      )
     read_in_decoder_q_k_v(UpperCAmelCase		,      UpperCAmelCase      )

     # fix some prefixes
     for key in state_dict.copy().keys():
          if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
               snake_case_       =      state_dict.pop(UpperCAmelCase      )
               snake_case_       =      val
          if "input_proj" in key:
               snake_case_       =      state_dict.pop(UpperCAmelCase      )
               snake_case_       =      val
          if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
               snake_case_       =      state_dict.pop(UpperCAmelCase      )
               snake_case_       =      val

    # finally, create HuggingFace model and load state dict
     snake_case_       =      DetaForObjectDetection(UpperCAmelCase      )
     model.load_state_dict(UpperCAmelCase      )
     model.eval()

     snake_case_       =      'cuda' if torch.cuda.is_available() else 'cpu'
     model.to(UpperCAmelCase      )

     # load image processor
     snake_case_       =      DetaImageProcessor(format='coco_detection'      )

     # verify our conversion on image
     snake_case_       =      prepare_img()
     snake_case_       =      processor(images=UpperCAmelCase		,      return_tensors='pt'      )
     snake_case_       =      encoding['pixel_values']
     snake_case_       =      model(pixel_values.to(UpperCAmelCase      )      )

     # verify logits
     if model_name == "deta-resnet-50":
          snake_case_       =      torch.tensor(
              [[-7.3_978, -2.5_406, -4.1_668], [-8.2_684, -3.9_933, -3.8_096], [-7.0_515, -3.7_973, -5.8_516]]      )
          snake_case_       =      torch.tensor([[0.5_043, 0.4_973, 0.9_998], [0.2_542, 0.5_489, 0.4_748], [0.5_490, 0.2_765, 0.0_570]]      )
     elif model_name == "deta-resnet-50-24-epochs":
          snake_case_       =      torch.tensor(
              [[-7.1_688, -2.4_857, -4.8_669], [-7.8_630, -3.8_154, -4.2_674], [-7.2_730, -4.1_865, -5.5_323]]      )
          snake_case_       =      torch.tensor([[0.5_021, 0.4_971, 0.9_994], [0.2_546, 0.5_486, 0.4_731], [0.1_686, 0.1_986, 0.2_142]]      )

     assert torch.allclose(outputs.logits[0, :3, :3]		,      expected_logits.to(UpperCAmelCase      )		,      atol=1e-4      )
     assert torch.allclose(outputs.pred_boxes[0, :3, :3]		,      expected_boxes.to(UpperCAmelCase      )		,      atol=1e-4      )
     print('Everything ok!'      )

     if pytorch_dump_folder_path:
          # Save model and processor
          logger.info(f'Saving PyTorch model and processor to {pytorch_dump_folder_path}...'      )
          Path(UpperCAmelCase      ).mkdir(exist_ok=UpperCAmelCase      )
          model.save_pretrained(UpperCAmelCase      )
          processor.save_pretrained(UpperCAmelCase      )

     # Push to hub
     if push_to_hub:
          print('Pushing model and processor to hub...'      )
          model.push_to_hub(f'jozhang97/{model_name}'      )
          processor.push_to_hub(f'jozhang97/{model_name}'      )


if __name__ == "__main__":
    __UpperCamelCase								=    argparse.ArgumentParser()

    parser.add_argument(
        '''--model_name''',
        type=str,
        default='''deta-resnet-50''',
        choices=['''deta-resnet-50''', '''deta-resnet-50-24-epochs'''],
        help='''Name of the model you\'d like to convert.''',
    )
    parser.add_argument(
        '''--pytorch_dump_folder_path''',
        default=None,
        type=str,
        help='''Path to the folder to output PyTorch model.''',
    )
    parser.add_argument(
        '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
    )
    __UpperCamelCase								=    parser.parse_args()
    convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)


"""simple docstring"""


import functools
from contextlib import contextmanager

import bert_score
from packaging import version

import datasets







@contextmanager
def       UpperCAmelCase					(	)       ->   str:
     def filter_log(UpperCAmelCase      ):
          return False if "This IS expected if you are initializing" in record.msg else True

     snake_case_       =      datasets.utils.logging.get_logger('transformers.modeling_utils'      )
     logger.addFilter(UpperCAmelCase      )
     try:
          yield
     finally:
          logger.removeFilter(UpperCAmelCase      )


__UpperCamelCase								=    '''\
@inproceedings{bert-score,
  title={BERTScore: Evaluating Text Generation with BERT},
  author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},
  booktitle={International Conference on Learning Representations},
  year={2020},
  url={https://openreview.net/forum?id=SkeHuCVFDr}
}
'''

__UpperCamelCase								=    '''\
BERTScore leverages the pre-trained contextual embeddings from BERT and matches words in candidate and reference
sentences by cosine similarity.
It has been shown to correlate with human judgment on sentence-level and system-level evaluation.
Moreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language
generation tasks.

See the project\'s README at https://github.com/Tiiiger/bert_score#readme for more information.
'''

__UpperCamelCase								=    '''
BERTScore Metrics with the hashcode from a source against one or more references.

Args:
    predictions (list of str): Prediction/candidate sentences.
    references (list of str or list of list of str): Reference sentences.
    lang (str): Language of the sentences; required (e.g. \'en\').
    model_type (str): Bert specification, default using the suggested
        model for the target language; has to specify at least one of
        `model_type` or `lang`.
    num_layers (int): The layer of representation to use,
        default using the number of layers tuned on WMT16 correlation data.
    verbose (bool): Turn on intermediate status update.
    idf (bool or dict): Use idf weighting; can also be a precomputed idf_dict.
    device (str): On which the contextual embedding model will be allocated on.
        If this argument is None, the model lives on cuda:0 if cuda is available.
    nthreads (int): Number of threads.
    batch_size (int): Bert score processing batch size,
        at least one of `model_type` or `lang`. `lang` needs to be
        specified when `rescale_with_baseline` is True.
    rescale_with_baseline (bool): Rescale bertscore with pre-computed baseline.
    baseline_path (str): Customized baseline file.
    use_fast_tokenizer (bool): `use_fast` parameter passed to HF tokenizer. New in version 0.3.10.

Returns:
    precision: Precision.
    recall: Recall.
    f1: F1 score.
    hashcode: Hashcode of the library.

Examples:

    >>> predictions = ["hello there", "general kenobi"]
    >>> references = ["hello there", "general kenobi"]
    >>> bertscore = datasets.load_metric("bertscore")
    >>> results = bertscore.compute(predictions=predictions, references=references, lang="en")
    >>> print([round(v, 2) for v in results["f1"]])
    [1.0, 1.0]
'''




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION					,	_KWARGS_DESCRIPTION     )
class 				UpperCamelCase      (       datasets.Metric     ):







       def 	a_		(				self)   ->   Dict:
            return datasets.MetricInfo(
                description=_DESCRIPTION,							citation=_CITATION,							homepage='https://github.com/Tiiiger/bert_score',							inputs_description=_KWARGS_DESCRIPTION,							features=datasets.Features(
                    {
                        'predictions': datasets.Value('string',							id='sequence'),
                        'references': datasets.Sequence(datasets.Value('string',							id='sequence'),							id='references'),
                    }),							codebase_urls=['https://github.com/Tiiiger/bert_score'],							reference_urls=[
                    'https://github.com/Tiiiger/bert_score',
                    'https://arxiv.org/abs/1904.09675',
                ],							)







       def 	a_		(				self,							lowerCAmelCase__,							lowerCAmelCase__,							lowerCAmelCase__=None,							lowerCAmelCase__=None,							lowerCAmelCase__=None,							lowerCAmelCase__=False,							lowerCAmelCase__=False,							lowerCAmelCase__=None,							lowerCAmelCase__=64,							lowerCAmelCase__=4,							lowerCAmelCase__=False,							lowerCAmelCase__=False,							lowerCAmelCase__=None,							lowerCAmelCase__=False,							)   ->   Union[str, Any]:
            snake_case_       =      bert_score.utils.get_hash
            snake_case_       =      bert_score.BERTScorer

            if version.parse(bert_score.__version__) >= version.parse('0.3.10'):
                 snake_case_       =      functools.partial(lowerCAmelCase__,							use_fast_tokenizer=lowerCAmelCase__)
                 snake_case_       =      functools.partial(lowerCAmelCase__,							use_fast_tokenizer=lowerCAmelCase__)
            elif use_fast_tokenizer:
                 raise ImportWarning(
                     'To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of `bert-score` doesn\'t match this condition.\n'
                     'You can install it with `pip install "bert-score>=0.3.10"`.')

            if model_type is None:
                 assert lang is not None, "either lang or model_type should be specified"
                 snake_case_       =      bert_score.utils.langamodel[lang.lower()]

            if num_layers is None:
                 snake_case_       =      bert_score.utils.modelalayers[model_type]

            snake_case_       =      get_hash(
                model=lowerCAmelCase__,							num_layers=lowerCAmelCase__,							idf=lowerCAmelCase__,							rescale_with_baseline=lowerCAmelCase__,							use_custom_baseline=baseline_path is not None,							)

            with filter_logging_context():
                 if not hasattr(self,							'cached_bertscorer') or self.cached_bertscorer.hash != hashcode:
                      snake_case_       =      scorer(
                          model_type=lowerCAmelCase__,							num_layers=lowerCAmelCase__,							batch_size=lowerCAmelCase__,							nthreads=lowerCAmelCase__,							all_layers=lowerCAmelCase__,							idf=lowerCAmelCase__,							device=lowerCAmelCase__,							lang=lowerCAmelCase__,							rescale_with_baseline=lowerCAmelCase__,							baseline_path=lowerCAmelCase__,							)

            ((snake_case_) ,			(snake_case_) ,			(snake_case_))       =      self.cached_bertscorer.score(
                cands=lowerCAmelCase__,							refs=lowerCAmelCase__,							verbose=lowerCAmelCase__,							batch_size=lowerCAmelCase__,							)
            snake_case_       =      {
                'precision': P.tolist(),
                'recall': R.tolist(),
                'f1': F.tolist(),
                'hashcode': hashcode,
            }
            return output_dict







       def 	a_		(				self,							lowerCAmelCase__=None,							lowerCAmelCase__=None,							**lowerCAmelCase__)   ->   List[str]:
            # References can be strings or lists of strings
            # Let's change strings to lists of strings with one element
            if references is not None:
                 snake_case_       =      [[ref] if isinstance(lowerCAmelCase__,							lowerCAmelCase__) else ref for ref in references]
            super().add_batch(predictions=lowerCAmelCase__,							references=lowerCAmelCase__,							**lowerCAmelCase__)







       def 	a_		(				self,							lowerCAmelCase__=None,							lowerCAmelCase__=None,							**lowerCAmelCase__)   ->   List[str]:
            # References can be strings or lists of strings
            # Let's change strings to lists of strings with one element
            if isinstance(lowerCAmelCase__,							lowerCAmelCase__):
                 snake_case_       =      [reference]
            super().add(prediction=lowerCAmelCase__,							reference=lowerCAmelCase__,							**lowerCAmelCase__)

