



"""simple docstring"""
import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


logging.set_verbosity_info()
UpperCAmelCase						:		Any			= logging.get_logger(__name__)


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase=False							) ->						str:







  '''simple docstring'''


  lowercase_								= []
  for i in range(config.num_hidden_layers							):
    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
    rename_keys.append((F'''blocks.{i}.norm1.weight''', F'''vit.encoder.layer.{i}.layernorm_before.weight''')							)
    rename_keys.append((F'''blocks.{i}.norm1.bias''', F'''vit.encoder.layer.{i}.layernorm_before.bias''')							)
    rename_keys.append((F'''blocks.{i}.attn.proj.weight''', F'''vit.encoder.layer.{i}.attention.output.dense.weight''')							)
    rename_keys.append((F'''blocks.{i}.attn.proj.bias''', F'''vit.encoder.layer.{i}.attention.output.dense.bias''')							)
    rename_keys.append((F'''blocks.{i}.norm2.weight''', F'''vit.encoder.layer.{i}.layernorm_after.weight''')							)
    rename_keys.append((F'''blocks.{i}.norm2.bias''', F'''vit.encoder.layer.{i}.layernorm_after.bias''')							)
    rename_keys.append((F'''blocks.{i}.mlp.fc1.weight''', F'''vit.encoder.layer.{i}.intermediate.dense.weight''')							)
    rename_keys.append((F'''blocks.{i}.mlp.fc1.bias''', F'''vit.encoder.layer.{i}.intermediate.dense.bias''')							)
    rename_keys.append((F'''blocks.{i}.mlp.fc2.weight''', F'''vit.encoder.layer.{i}.output.dense.weight''')							)
    rename_keys.append((F'''blocks.{i}.mlp.fc2.bias''', F'''vit.encoder.layer.{i}.output.dense.bias''')							)

  # projection layer + position embeddings
  rename_keys.extend(
      [
          ("""cls_token""", """vit.embeddings.cls_token"""),
          ("""patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight"""),
          ("""patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias"""),
          ("""pos_embed""", """vit.embeddings.position_embeddings"""),
      ]							)

  if base_model:
    # layernorm + pooler
    rename_keys.extend(
        [
            ("""norm.weight""", """layernorm.weight"""),
            ("""norm.bias""", """layernorm.bias"""),
        ]							)

    # if just the base model, we should remove "vit" from all keys that start with "vit"
    lowercase_								= [(pair[0], pair[1][4:]) if pair[1].startswith("""vit"""							) else pair for pair in rename_keys]
  else:
    # layernorm + classification head
    rename_keys.extend(
        [
            ("""norm.weight""", """vit.layernorm.weight"""),
            ("""norm.bias""", """vit.layernorm.bias"""),
            ("""head.weight""", """classifier.weight"""),
            ("""head.bias""", """classifier.bias"""),
        ]							)

  return rename_keys


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase=False							) ->						Any:







  '''simple docstring'''


  for i in range(config.num_hidden_layers							):
    if base_model:
      lowercase_								= """"""
    else:
      lowercase_								= """vit."""
    # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
    lowercase_								= state_dict.pop(F'''blocks.{i}.attn.qkv.weight'''							)
    lowercase_								= state_dict.pop(F'''blocks.{i}.attn.qkv.bias'''							)
    # next, add query, keys and values (in that order) to the state dict
    lowercase_								= in_proj_weight[
        : config.hidden_size, :
    ]
    lowercase_								= in_proj_bias[: config.hidden_size]
    lowercase_								= in_proj_weight[
        config.hidden_size : config.hidden_size * 2, :
    ]
    lowercase_								= in_proj_bias[
        config.hidden_size : config.hidden_size * 2
    ]
    lowercase_								= in_proj_weight[
        -config.hidden_size :, :
    ]
    lowercase_								= in_proj_bias[-config.hidden_size :]


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase							) ->						str:







  '''simple docstring'''


  lowercase_								= ["""head.weight""", """head.bias"""]
  for k in ignore_keys:
    state_dict.pop(__lowerCAmelCase ,  __lowerCAmelCase							)


def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							) ->						Union[str, Any]:







  '''simple docstring'''


  lowercase_								= dct.pop(__lowerCAmelCase							)
  lowercase_								= val


def 			_SCREAMING_SNAKE_CASE						() ->						Any:







  '''simple docstring'''


  lowercase_								= """http://images.cocodataset.org/val2017/000000039769.jpg"""
  lowercase_								= Image.open(requests.get(__lowerCAmelCase ,  stream=__lowerCAmelCase							).raw							)
  return im


@torch.no_grad()
def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase=True							) ->						Optional[int]:







  '''simple docstring'''


  lowercase_								= ViTConfig()
  # patch_size
  if model_name[-1] == "8":
    lowercase_								= 8
  # set labels if required
  if not base_model:
    lowercase_								= 10_00
    lowercase_								= """huggingface/label-files"""
    lowercase_								= """imagenet-1k-id2label.json"""
    lowercase_								= json.load(open(hf_hub_download(__lowerCAmelCase ,  __lowerCAmelCase ,  repo_type="""dataset"""							) ,  """r"""							)							)
    lowercase_								= {int(__lowerCAmelCase							): v for k, v in idalabel.items()}
    lowercase_								= idalabel
    lowercase_								= {v: k for k, v in idalabel.items()}
  # size of the architecture
  if model_name in ["dino_vits8", "dino_vits16"]:
    lowercase_								= 3_84
    lowercase_								= 15_36
    lowercase_								= 12
    lowercase_								= 6

  # load original model from torch hub
  lowercase_								= torch.hub.load("""facebookresearch/dino:main""" ,  __lowerCAmelCase							)
  original_model.eval()

  # load state_dict of original model, remove and rename some keys
  lowercase_								= original_model.state_dict()
  if base_model:
    remove_classification_head_(__lowerCAmelCase							)
  lowercase_								= create_rename_keys(__lowerCAmelCase ,  base_model=__lowerCAmelCase							)
  for src, dest in rename_keys:
    rename_key(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							)
  read_in_q_k_v(__lowerCAmelCase ,  __lowerCAmelCase ,  __lowerCAmelCase							)

  # load HuggingFace model
  if base_model:
    lowercase_								= ViTModel(__lowerCAmelCase ,  add_pooling_layer=__lowerCAmelCase							).eval()
  else:
    lowercase_								= ViTForImageClassification(__lowerCAmelCase							).eval()
  model.load_state_dict(__lowerCAmelCase							)

  # Check outputs on an image, prepared by ViTImageProcessor
  lowercase_								= ViTImageProcessor()
  lowercase_								= image_processor(images=prepare_img() ,  return_tensors="""pt"""							)
  lowercase_								= encoding["""pixel_values"""]
  lowercase_								= model(__lowerCAmelCase							)

  if base_model:
    lowercase_								= original_model(__lowerCAmelCase							)
    assert torch.allclose(__lowerCAmelCase ,  outputs.last_hidden_state[:, 0, :] ,  atol=1E-1							)
  else:
    lowercase_								= original_model(__lowerCAmelCase							)
    assert logits.shape == outputs.logits.shape
    assert torch.allclose(__lowerCAmelCase ,  outputs.logits ,  atol=1E-3							)

  Path(__lowerCAmelCase							).mkdir(exist_ok=__lowerCAmelCase							)
  print(F'''Saving model {model_name} to {pytorch_dump_folder_path}'''							)
  model.save_pretrained(__lowerCAmelCase							)
  print(F'''Saving image processor to {pytorch_dump_folder_path}'''							)
  image_processor.save_pretrained(__lowerCAmelCase							)


if __name__ == "__main__":
       UpperCAmelCase						:		str			= argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           "--model_name",
           default="dino_vitb16",
           type=str,
           help="Name of the model trained with DINO you'd like to convert.",
       )
       parser.add_argument(
           "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
       )
       parser.add_argument(
           "--base_model",
           action="store_true",
           help="Whether to only convert the base model (no projection head weights).",
       )

       parser.set_defaults(base_model=True)
       UpperCAmelCase						:		List[Any]			= parser.parse_args()
       convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)






"""simple docstring"""
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, PLBartTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


UpperCAmelCase						:		str			= get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
       from transformers.models.plbart.modeling_plbart import shift_tokens_right

UpperCAmelCase						:		int			= 5_0003
UpperCAmelCase						:		Optional[Any]			= 5_0002


@require_sentencepiece
@require_tokenizers
class    SCREAMING_SNAKE_CASE__ (							__UpperCAmelCase      ,  unittest.TestCase   ):
    lowercase__      =   PLBartTokenizer
    lowercase__      =   None
    lowercase__      =   False

    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      super().setUp()

      # We have a SentencePiece fixture for testing
      lowercase_								= PLBartTokenizer(lowerCAmelCase_ ,  language_codes="""base""" ,  keep_accents=lowerCAmelCase_)
      tokenizer.save_pretrained(self.tmpdirname)

    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      lowercase_								= PLBartTokenizer(lowerCAmelCase_ ,  language_codes="""base""" ,  keep_accents=lowerCAmelCase_)

      lowercase_								= tokenizer.tokenize("""This is a test""")
      self.assertListEqual(lowerCAmelCase_ ,  ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""])

      self.assertListEqual(
          tokenizer.convert_tokens_to_ids(lowerCAmelCase_) ,  [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]] ,  )

      lowercase_								= tokenizer.tokenize("""I was born in 92000, and this is falsé.""")
      self.assertListEqual(
          lowerCAmelCase_ ,  [
              SPIECE_UNDERLINE + """I""",
              SPIECE_UNDERLINE + """was""",
              SPIECE_UNDERLINE + """b""",
              """or""",
              """n""",
              SPIECE_UNDERLINE + """in""",
              SPIECE_UNDERLINE + """""",
              """9""",
              """2""",
              """0""",
              """0""",
              """0""",
              """,""",
              SPIECE_UNDERLINE + """and""",
              SPIECE_UNDERLINE + """this""",
              SPIECE_UNDERLINE + """is""",
              SPIECE_UNDERLINE + """f""",
              """al""",
              """s""",
              """é""",
              """.""",
          ] ,  )
      lowercase_								= tokenizer.convert_tokens_to_ids(lowerCAmelCase_)
      self.assertListEqual(
          lowerCAmelCase_ ,  [
              value + tokenizer.fairseq_offset
              for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
          ] ,  )

      lowercase_								= tokenizer.convert_ids_to_tokens(lowerCAmelCase_)
      self.assertListEqual(
          lowerCAmelCase_ ,  [
              SPIECE_UNDERLINE + """I""",
              SPIECE_UNDERLINE + """was""",
              SPIECE_UNDERLINE + """b""",
              """or""",
              """n""",
              SPIECE_UNDERLINE + """in""",
              SPIECE_UNDERLINE + """""",
              """<unk>""",
              """2""",
              """0""",
              """0""",
              """0""",
              """,""",
              SPIECE_UNDERLINE + """and""",
              SPIECE_UNDERLINE + """this""",
              SPIECE_UNDERLINE + """is""",
              SPIECE_UNDERLINE + """f""",
              """al""",
              """s""",
              """<unk>""",
              """.""",
          ] ,  )

      lowercase_								= tokenizer.vocab_size
      lowercase_								= [tokenizer.convert_ids_to_tokens(lowerCAmelCase_) for x in range(end - 4 ,  lowerCAmelCase_)]

      self.assertListEqual(lowerCAmelCase_ ,  ["""__java__""", """__python__""", """__en_XX__""", """<mask>"""])

      lowercase_								= """java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"""
      lowercase_								= tokenizer(lowerCAmelCase_).input_ids
      self.assertEqual(
          tokenizer.decode(lowerCAmelCase_ ,  skip_special_tokens=lowerCAmelCase_ ,  clean_up_tokenization_spaces=lowerCAmelCase_) ,  lowerCAmelCase_ ,  )




    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= PLBartTokenizer(lowerCAmelCase_ ,  language_codes="""multi""" ,  keep_accents=lowerCAmelCase_)

      lowercase_								= tokenizer.tokenize("""This is a test""")
      self.assertListEqual(lowerCAmelCase_ ,  ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""])

      self.assertListEqual(
          tokenizer.convert_tokens_to_ids(lowerCAmelCase_) ,  [value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]] ,  )

      lowercase_								= tokenizer.tokenize("""I was born in 92000, and this is falsé.""")
      self.assertListEqual(
          lowerCAmelCase_ ,  [
              SPIECE_UNDERLINE + """I""",
              SPIECE_UNDERLINE + """was""",
              SPIECE_UNDERLINE + """b""",
              """or""",
              """n""",
              SPIECE_UNDERLINE + """in""",
              SPIECE_UNDERLINE + """""",
              """9""",
              """2""",
              """0""",
              """0""",
              """0""",
              """,""",
              SPIECE_UNDERLINE + """and""",
              SPIECE_UNDERLINE + """this""",
              SPIECE_UNDERLINE + """is""",
              SPIECE_UNDERLINE + """f""",
              """al""",
              """s""",
              """é""",
              """.""",
          ] ,  )
      lowercase_								= tokenizer.convert_tokens_to_ids(lowerCAmelCase_)
      self.assertListEqual(
          lowerCAmelCase_ ,  [
              value + tokenizer.fairseq_offset
              for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
          ] ,  )

      lowercase_								= tokenizer.convert_ids_to_tokens(lowerCAmelCase_)
      self.assertListEqual(
          lowerCAmelCase_ ,  [
              SPIECE_UNDERLINE + """I""",
              SPIECE_UNDERLINE + """was""",
              SPIECE_UNDERLINE + """b""",
              """or""",
              """n""",
              SPIECE_UNDERLINE + """in""",
              SPIECE_UNDERLINE + """""",
              """<unk>""",
              """2""",
              """0""",
              """0""",
              """0""",
              """,""",
              SPIECE_UNDERLINE + """and""",
              SPIECE_UNDERLINE + """this""",
              SPIECE_UNDERLINE + """is""",
              SPIECE_UNDERLINE + """f""",
              """al""",
              """s""",
              """<unk>""",
              """.""",
          ] ,  )
      lowercase_								= tokenizer.vocab_size
      lowercase_								= [tokenizer.convert_ids_to_tokens(lowerCAmelCase_) for x in range(end - 7 ,  lowerCAmelCase_)]

      self.assertListEqual(
          lowerCAmelCase_ ,  ["""__java__""", """__python__""", """__en_XX__""", """__javascript__""", """__php__""", """__ruby__""", """__go__"""])
      lowercase_								= """java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"""
      lowercase_								= tokenizer(lowerCAmelCase_).input_ids
      self.assertEqual(
          tokenizer.decode(lowerCAmelCase_ ,  skip_special_tokens=lowerCAmelCase_ ,  clean_up_tokenization_spaces=lowerCAmelCase_) ,  lowerCAmelCase_ ,  )







@require_torch
@require_sentencepiece
@require_tokenizers
class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):
    lowercase__      =   "uclanlp/plbart-python-en_XX"
    lowercase__      =   [
        "def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])",
        "def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])",
    ]
    lowercase__      =   [
        "Returns the maximum value of a b c.",
        "Sums the values of a b c.",
    ]
    lowercase__      =   [
        134,
        5452,
        33460,
        33441,
        33463,
        33465,
        33463,
        33449,
        988,
        20,
        33456,
        19,
        33456,
        771,
        39,
        4258,
        889,
        3318,
        33441,
        33463,
        33465,
        33463,
        33449,
        2471,
        2,
        PYTHON_CODE,
    ]

    @classmethod
    def 					_UpperCAmelCase	(				cls			:				List[Any]):







      """simple docstring"""







      lowercase_								= PLBartTokenizer.from_pretrained(
          cls.checkpoint_name ,  language_codes="""base""" ,  src_lang="""python""" ,  tgt_lang="""en_XX""")
      lowercase_								= 1
      return cls

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""__java__"""] ,  5_0_0_0_1)
      self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""__python__"""] ,  5_0_0_0_2)
      self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""__en_XX__"""] ,  5_0_0_0_3)

    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= self.tokenizer.batch_encode_plus(self.src_text).input_ids[0]
      self.assertListEqual(self.expected_src_tokens ,  lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      self.assertIn(lowerCAmelCase_ ,  self.tokenizer.all_special_ids)
      lowercase_								= [EN_CODE, 9_0_3_7, 3_3_4_4_2, 5_7, 7_5_2, 1_5_3, 1_4, 5_6, 1_8, 9, 2]
      lowercase_								= self.tokenizer.decode(lowerCAmelCase_ ,  skip_special_tokens=lowerCAmelCase_)
      lowercase_								= self.tokenizer.decode(generated_ids[1:] ,  skip_special_tokens=lowerCAmelCase_)
      self.assertEqual(lowerCAmelCase_ ,  lowerCAmelCase_)
      self.assertNotIn(self.tokenizer.eos_token ,  lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      lowercase_								= ["""def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])""" * 2_0]
      self.assertIsInstance(src_text[0] ,  lowerCAmelCase_)
      lowercase_								= 1_0
      lowercase_								= self.tokenizer(lowerCAmelCase_ ,  max_length=lowerCAmelCase_ ,  truncation=lowerCAmelCase_).input_ids[0]
      self.assertEqual(ids[-2] ,  2)
      self.assertEqual(ids[-1] ,  lowerCAmelCase_)
      self.assertEqual(len(lowerCAmelCase_) ,  lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """__java__"""]) ,  [5_0_0_0_4, 5_0_0_0_1])

    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_								= tempfile.mkdtemp()
      lowercase_								= self.tokenizer.fairseq_tokens_to_ids
      self.tokenizer.save_pretrained(lowerCAmelCase_)
      lowercase_								= PLBartTokenizer.from_pretrained(lowerCAmelCase_)
      self.assertDictEqual(new_tok.fairseq_tokens_to_ids ,  lowerCAmelCase_)

    @require_torch
    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      lowercase_								= self.tokenizer(self.src_text ,  text_target=self.tgt_text ,  padding=lowerCAmelCase_ ,  return_tensors="""pt""")
      lowercase_								= shift_tokens_right(batch["""labels"""] ,  self.tokenizer.pad_token_id)

      # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
      self.assertEqual(batch.input_ids[1][-2:].tolist() ,  [2, PYTHON_CODE])
      self.assertEqual(batch.decoder_input_ids[1][0] ,  lowerCAmelCase_)
      self.assertEqual(batch.decoder_input_ids[1][-1] ,  2)
      self.assertEqual(batch.labels[1][-2:].tolist() ,  [2, EN_CODE])

    @require_torch
    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= self.tokenizer(
          self.src_text ,  text_target=self.tgt_text ,  padding=lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=len(self.expected_src_tokens) ,  return_tensors="""pt""" ,  )
      lowercase_								= shift_tokens_right(batch["""labels"""] ,  self.tokenizer.pad_token_id)

      self.assertIsInstance(lowerCAmelCase_ ,  lowerCAmelCase_)

      self.assertEqual((2, 2_6) ,  batch.input_ids.shape)
      self.assertEqual((2, 2_6) ,  batch.attention_mask.shape)
      lowercase_								= batch.input_ids.tolist()[0]
      self.assertListEqual(self.expected_src_tokens ,  lowerCAmelCase_)
      self.assertEqual(2 ,  batch.decoder_input_ids[0, -1])  # EOS
      # Test that special tokens are reset
      self.assertEqual(self.tokenizer.prefix_tokens ,  [])
      self.assertEqual(self.tokenizer.suffix_tokens ,  [self.tokenizer.eos_token_id, PYTHON_CODE])

    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      lowercase_								= self.tokenizer(self.src_text ,  padding=lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=3 ,  return_tensors="""pt""")
      lowercase_								= self.tokenizer(
          text_target=self.tgt_text ,  padding=lowerCAmelCase_ ,  truncation=lowerCAmelCase_ ,  max_length=1_0 ,  return_tensors="""pt""")
      lowercase_								= targets["""input_ids"""]
      lowercase_								= shift_tokens_right(lowerCAmelCase_ ,  self.tokenizer.pad_token_id)

      self.assertEqual(batch.input_ids.shape[1] ,  3)
      self.assertEqual(batch.decoder_input_ids.shape[1] ,  1_0)




    @require_torch
    def 					_UpperCAmelCase	(				self			:				Dict):







      """simple docstring"""







      lowercase_								= self.tokenizer._build_translation_inputs(
          """A test""" ,  return_tensors="""pt""" ,  src_lang="""en_XX""" ,  tgt_lang="""java""")

      self.assertEqual(
          nested_simplify(lowerCAmelCase_) ,  {
              # A, test, EOS, en_XX
              """input_ids""": [[1_5_0, 2_4_2, 2, 5_0_0_0_3]],
              """attention_mask""": [[1, 1, 1, 1]],
              # java
              """forced_bos_token_id""": 5_0_0_0_1,
          } ,  )

