






"""simple docstring"""







import shutil
import tempfile
import unittest

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

from ...test_tokenization_common import TokenizerTesterMixin


_UpperCamelCase	     =    get_tests_dir("""fixtures/test_sentencepiece.model""")

if is_torch_available():
  from transformers.models.mbart.modeling_mbart import shift_tokens_right

_UpperCamelCase	     =    250004
_UpperCamelCase	     =    250020







@require_sentencepiece
@require_tokenizers
class    lowerCamelCase__   (			snake_case       ,	unittest.TestCase					):
    SCREAMING_SNAKE_CASE						=     MBartaaTokenizer
    SCREAMING_SNAKE_CASE						=     MBartaaTokenizerFast
    SCREAMING_SNAKE_CASE						=     True
    SCREAMING_SNAKE_CASE						=     True






    def 							_UpperCamelCase				(					self   ):
          super().setUp()

          # We have a SentencePiece fixture for testing
          UpperCAmelCase							     =			MBartaaTokenizer(_lowerCAmelCase      ,src_lang="""en_XX"""      ,tgt_lang="""ro_RO"""      ,keep_accents=_lowerCAmelCase   )
          tokenizer.save_pretrained(self.tmpdirname   )






    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			"""<s>"""
          UpperCAmelCase							     =			0

          self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowerCAmelCase   )      ,_lowerCAmelCase   )
          self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowerCAmelCase   )      ,_lowerCAmelCase   )






    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			list(self.get_tokenizer().get_vocab().keys()   )

          self.assertEqual(vocab_keys[0]      ,"""<s>"""   )
          self.assertEqual(vocab_keys[1]      ,"""<pad>"""   )
          self.assertEqual(vocab_keys[-1]      ,"""<mask>"""   )
          self.assertEqual(len(_lowerCAmelCase   )      ,1_054   )






    def 							_UpperCamelCase				(					self   ):
          self.assertEqual(self.get_tokenizer().vocab_size      ,1_054   )






    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			MBartaaTokenizer(_lowerCAmelCase      ,src_lang="""en_XX"""      ,tgt_lang="""ro_RO"""      ,keep_accents=_lowerCAmelCase   )

          UpperCAmelCase							     =			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 [285, 46, 10, 170, 382]]      ,)

          UpperCAmelCase							     =			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""", """é""", """."""]      ,)
          UpperCAmelCase							     =			tokenizer.convert_tokens_to_ids(_lowerCAmelCase   )
          self.assertListEqual(
              _lowerCAmelCase      ,[
                  value + tokenizer.fairseq_offset
                  for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
              ]      ,)

          UpperCAmelCase							     =			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>""", """."""]      ,)






    @slow
    def 							_UpperCamelCase				(					self   ):
          # fmt: off
          UpperCAmelCase							     =			{"""input_ids""": [[250_004, 11_062, 82_772, 7, 15, 82_772, 538, 51_529, 237, 17_198, 1_290, 206, 9, 215_175, 1_314, 136, 17_198, 1_290, 206, 9, 56_359, 42, 122_009, 9, 16_466, 16, 87_344, 4_537, 9, 4_717, 78_381, 6, 159_958, 7, 15, 24_480, 618, 4, 527, 22_693, 5_428, 4, 2_777, 24_480, 9_874, 4, 43_523, 594, 4, 803, 18_392, 33_189, 18, 4, 43_523, 24_447, 12_399, 100, 24_955, 83_658, 9_626, 144_057, 15, 839, 22_335, 16, 136, 24_955, 83_658, 83_479, 15, 39_102, 724, 16, 678, 645, 2_789, 1_328, 4_589, 42, 122_009, 115_774, 23, 805, 1_328, 46_876, 7, 136, 53_894, 1_940, 42_227, 41_159, 17_721, 823, 425, 4, 27_512, 98_722, 206, 136, 5_531, 4_970, 919, 17_336, 5, 2], [250_004, 20_080, 618, 83, 82_775, 47, 479, 9, 1_517, 73, 53_894, 333, 80_581, 110_117, 18_811, 5_256, 1_295, 51, 152_526, 297, 7_986, 390, 124_416, 538, 35_431, 214, 98, 15_044, 25_737, 136, 7_108, 43_701, 23, 756, 135_355, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [250_004, 581, 63_773, 119_455, 6, 147_797, 88_203, 7, 645, 70, 21, 3_285, 10_269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
          # fmt: on

          self.tokenizer_integration_test_util(
              expected_encoding=_lowerCAmelCase      ,model_name="""facebook/mbart-large-50"""      ,revision="""d3913889c59cd5c9e456b269c376325eabad57e2"""      ,)






    def 							_UpperCamelCase				(					self   ):
          if not self.test_slow_tokenizer:
                # as we don't have a slow version, we can't compare the outputs between slow and fast versions
                return

          UpperCAmelCase							     =			(self.rust_tokenizer_class, """hf-internal-testing/tiny-random-mbart50""", {})
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''   ):
                      UpperCAmelCase							     =			self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase      ,**_lowerCAmelCase   )
                      UpperCAmelCase							     =			self.tokenizer_class.from_pretrained(_lowerCAmelCase      ,**_lowerCAmelCase   )

                      UpperCAmelCase							     =			tempfile.mkdtemp()

                      UpperCAmelCase							     =			tokenizer_r.save_pretrained(_lowerCAmelCase   )
                      UpperCAmelCase							     =			tokenizer_p.save_pretrained(_lowerCAmelCase   )

                      # Checks it save with the same files + the tokenizer.json file for the fast one
                      self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files   )   )
                      UpperCAmelCase							     =			tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f   )
                      self.assertSequenceEqual(_lowerCAmelCase      ,_lowerCAmelCase   )

                      # Checks everything loads correctly in the same way
                      UpperCAmelCase							     =			tokenizer_r.from_pretrained(_lowerCAmelCase   )
                      UpperCAmelCase							     =			tokenizer_p.from_pretrained(_lowerCAmelCase   )

                      # Check special tokens are set accordingly on Rust and Python
                      for key in tokenizer_pp.special_tokens_map:
                            self.assertTrue(hasattr(_lowerCAmelCase      ,_lowerCAmelCase   )   )
                            # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                            # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                      shutil.rmtree(_lowerCAmelCase   )

                      # Save tokenizer rust, legacy_format=True
                      UpperCAmelCase							     =			tempfile.mkdtemp()

                      UpperCAmelCase							     =			tokenizer_r.save_pretrained(_lowerCAmelCase      ,legacy_format=_lowerCAmelCase   )
                      UpperCAmelCase							     =			tokenizer_p.save_pretrained(_lowerCAmelCase   )

                      # Checks it save with the same files
                      self.assertSequenceEqual(_lowerCAmelCase      ,_lowerCAmelCase   )

                      # Checks everything loads correctly in the same way
                      UpperCAmelCase							     =			tokenizer_r.from_pretrained(_lowerCAmelCase   )
                      UpperCAmelCase							     =			tokenizer_p.from_pretrained(_lowerCAmelCase   )

                      # Check special tokens are set accordingly on Rust and Python
                      for key in tokenizer_pp.special_tokens_map:
                            self.assertTrue(hasattr(_lowerCAmelCase      ,_lowerCAmelCase   )   )

                      shutil.rmtree(_lowerCAmelCase   )

                      # Save tokenizer rust, legacy_format=False
                      UpperCAmelCase							     =			tempfile.mkdtemp()

                      UpperCAmelCase							     =			tokenizer_r.save_pretrained(_lowerCAmelCase      ,legacy_format=_lowerCAmelCase   )
                      UpperCAmelCase							     =			tokenizer_p.save_pretrained(_lowerCAmelCase   )

                      # Checks it saved the tokenizer.json file
                      self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files   )   )

                      # Checks everything loads correctly in the same way
                      UpperCAmelCase							     =			tokenizer_r.from_pretrained(_lowerCAmelCase   )
                      UpperCAmelCase							     =			tokenizer_p.from_pretrained(_lowerCAmelCase   )

                      # Check special tokens are set accordingly on Rust and Python
                      for key in tokenizer_pp.special_tokens_map:
                            self.assertTrue(hasattr(_lowerCAmelCase      ,_lowerCAmelCase   )   )

                      shutil.rmtree(_lowerCAmelCase   )







@require_torch
@require_sentencepiece
@require_tokenizers
class    lowerCamelCase__   (			unittest.TestCase					):
    SCREAMING_SNAKE_CASE						=     "facebook/mbart-large-50-one-to-many-mmt"
    SCREAMING_SNAKE_CASE						=     [
        " UN Chief Says There Is No Military Solution in Syria",
        " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
    ]
    SCREAMING_SNAKE_CASE						=     [
        "Şeful ONU declară că nu există o soluţie militară în Siria",
        "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
        " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
        " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
    ]
    SCREAMING_SNAKE_CASE						=     [EN_CODE, 8_274, 127_873, 25_916, 7, 8_622, 2_071, 438, 67_485, 53, 187_895, 23, 51_712, 2]






    @classmethod
    def 							_UpperCamelCase				(					cls   ):
          UpperCAmelCase							     =			MBartaaTokenizer.from_pretrained(
              cls.checkpoint_name      ,src_lang="""en_XX"""      ,tgt_lang="""ro_RO"""   )
          UpperCAmelCase							     =			1
          return cls






    def 							_UpperCamelCase				(					self   ):
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ar_AR"""]      ,250_001   )
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""en_EN"""]      ,250_004   )
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ro_RO"""]      ,250_020   )
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""mr_IN"""]      ,250_038   )






    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			self.tokenizer.batch_encode_plus(self.src_text   ).input_ids[0]
          self.assertListEqual(self.expected_src_tokens      ,_lowerCAmelCase   )






    def 							_UpperCamelCase				(					self   ):
          self.assertIn(_lowerCAmelCase      ,self.tokenizer.all_special_ids   )
          UpperCAmelCase							     =			[RO_CODE, 884, 9_019, 96, 9, 916, 86_792, 36, 18_743, 15_596, 5, 2]
          UpperCAmelCase							     =			self.tokenizer.decode(_lowerCAmelCase      ,skip_special_tokens=_lowerCAmelCase   )
          UpperCAmelCase							     =			self.tokenizer.decode(generated_ids[1:]      ,skip_special_tokens=_lowerCAmelCase   )
          self.assertEqual(_lowerCAmelCase      ,_lowerCAmelCase   )
          self.assertNotIn(self.tokenizer.eos_token      ,_lowerCAmelCase   )






    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			["""this is gunna be a long sentence """ * 20]
          assert isinstance(src_text[0]      ,_lowerCAmelCase   )
          UpperCAmelCase							     =			10
          UpperCAmelCase							     =			self.tokenizer(_lowerCAmelCase      ,max_length=_lowerCAmelCase      ,truncation=_lowerCAmelCase   ).input_ids[0]
          self.assertEqual(ids[0]      ,_lowerCAmelCase   )
          self.assertEqual(ids[-1]      ,2   )
          self.assertEqual(len(_lowerCAmelCase   )      ,_lowerCAmelCase   )






    def 							_UpperCamelCase				(					self   ):
          self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]   )      ,[250_053, 250_001]   )






    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			tempfile.mkdtemp()
          UpperCAmelCase							     =			self.tokenizer.fairseq_tokens_to_ids
          self.tokenizer.save_pretrained(_lowerCAmelCase   )
          UpperCAmelCase							     =			MBartaaTokenizer.from_pretrained(_lowerCAmelCase   )
          self.assertDictEqual(new_tok.fairseq_tokens_to_ids      ,_lowerCAmelCase   )






    @require_torch
    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			self.tokenizer(self.src_text      ,text_target=self.tgt_text      ,padding=_lowerCAmelCase      ,return_tensors="""pt"""   )
          UpperCAmelCase							     =			shift_tokens_right(batch["""labels"""]      ,self.tokenizer.pad_token_id   )

          # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
          assert batch.input_ids[1][0] == EN_CODE
          assert batch.input_ids[1][-1] == 2
          assert batch.labels[1][0] == RO_CODE
          assert batch.labels[1][-1] == 2
          assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]






    @require_torch
    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			self.tokenizer(
              self.src_text      ,text_target=self.tgt_text      ,padding=_lowerCAmelCase      ,truncation=_lowerCAmelCase      ,max_length=len(self.expected_src_tokens   )      ,return_tensors="""pt"""      ,)
          UpperCAmelCase							     =			shift_tokens_right(batch["""labels"""]      ,self.tokenizer.pad_token_id   )

          self.assertIsInstance(_lowerCAmelCase      ,_lowerCAmelCase   )

          self.assertEqual((2, 14)      ,batch.input_ids.shape   )
          self.assertEqual((2, 14)      ,batch.attention_mask.shape   )
          UpperCAmelCase							     =			batch.input_ids.tolist()[0]
          self.assertListEqual(self.expected_src_tokens      ,_lowerCAmelCase   )
          self.assertEqual(2      ,batch.decoder_input_ids[0, 0]   )  # decoder_start_token_id
          # Test that special tokens are reset
          self.assertEqual(self.tokenizer.prefix_tokens      ,[EN_CODE]   )
          self.assertEqual(self.tokenizer.suffix_tokens      ,[self.tokenizer.eos_token_id]   )






    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			self.tokenizer(self.src_text      ,padding=_lowerCAmelCase      ,truncation=_lowerCAmelCase      ,max_length=3      ,return_tensors="""pt"""   )
          UpperCAmelCase							     =			self.tokenizer(
              text_target=self.tgt_text      ,padding=_lowerCAmelCase      ,truncation=_lowerCAmelCase      ,max_length=10      ,return_tensors="""pt"""   )
          UpperCAmelCase							     =			targets["""input_ids"""]
          UpperCAmelCase							     =			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]      ,10   )






    @require_torch
    def 							_UpperCamelCase				(					self   ):
          UpperCAmelCase							     =			self.tokenizer._build_translation_inputs(
              """A test"""      ,return_tensors="""pt"""      ,src_lang="""en_XX"""      ,tgt_lang="""ar_AR"""   )

          self.assertEqual(
              nested_simplify(_lowerCAmelCase   )      ,{
                  # en_XX, A, test, EOS
                  """input_ids""": [[250_004, 62, 3_034, 2]],
                  """attention_mask""": [[1, 1, 1, 1]],
                  # ar_AR
                  """forced_bos_token_id""": 250_001,
              }      ,)










'''simple docstring'''


from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE									=				logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE									=				{
    "facebook/deit-base-distilled-patch16-224": (
        "https://huggingface.co/facebook/deit-base-patch16-224/resolve/main/config.json"
    ),
    # See all DeiT models at https://huggingface.co/models?filter=deit
}

class  lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase    :				Optional[int]								=       "deit"




 def __init__(						self      ,  _lowerCAmelCase=768      ,  _lowerCAmelCase=12      ,  _lowerCAmelCase=12      ,  _lowerCAmelCase=3072      ,  _lowerCAmelCase="gelu"      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=0.02      ,  _lowerCAmelCase=1E-12      ,  _lowerCAmelCase=224      ,  _lowerCAmelCase=16      ,  _lowerCAmelCase=3      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=16      ,  **_lowerCAmelCase      ,  )     ->				Dict:
     super().__init__(**_lowerCAmelCase		)

     _lowerCAmelCase						      =   hidden_size
     _lowerCAmelCase						      =   num_hidden_layers
     _lowerCAmelCase						      =   num_attention_heads
     _lowerCAmelCase						      =   intermediate_size
     _lowerCAmelCase						      =   hidden_act
     _lowerCAmelCase						      =   hidden_dropout_prob
     _lowerCAmelCase						      =   attention_probs_dropout_prob
     _lowerCAmelCase						      =   initializer_range
     _lowerCAmelCase						      =   layer_norm_eps
     _lowerCAmelCase						      =   image_size
     _lowerCAmelCase						      =   patch_size
     _lowerCAmelCase						      =   num_channels
     _lowerCAmelCase						      =   qkv_bias
     _lowerCAmelCase						      =   encoder_stride







class  lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase    :				List[str]								=       version.parse("1.11"		)




 @property
 def 				_snake_case (						self		)     ->				Mapping[str, Mapping[int, str]]:
     return OrderedDict(
         [
             ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
         ]		)





 @property
 def 				_snake_case (						self		)     ->				float:
     return 1E-4


