'''simple docstring'''




from __future__ import annotations

import inspect
import unittest
from math import floor

import numpy as np

from transformers import CvtConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import TFCvtForImageClassification, TFCvtModel
  from transformers.models.cvt.modeling_tf_cvt import TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor




class    a__				(       UpperCAmelCase__			):






     def        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         __lowerCamelCase          =  self.config_class(**self.inputs_dict   )
         self.parent.assertTrue(hasattr(a  ,    '''embed_dim'''   )   )
         self.parent.assertTrue(hasattr(a  ,    '''num_heads'''   )   )




class    a__				:






     def __init__(			self		:		Dict  ,    a		:		Union[str, Any]  ,    a		:		Optional[Any]=13  ,    a		:		Optional[Any]=64  ,    a		:		Tuple=3  ,    a		:		Tuple=[16, 48, 96]  ,    a		:		int=[1, 3, 6]  ,    a		:		Optional[Any]=[1, 2, 10]  ,    a		:		Tuple=[7, 3, 3]  ,    a		:		Tuple=[4, 2, 2]  ,    a		:		Tuple=[2, 1, 1]  ,    a		:		Tuple=[2, 2, 2]  ,    a		:		Any=[False, False, True]  ,    a		:		Optional[Any]=[0.0, 0.0, 0.0]  ,    a		:		Dict=0.02  ,    a		:		str=1e-1_2  ,    a		:		Any=True  ,    a		:		Tuple=True  ,    a		:		int=2  ,    ):





         """simple docstring"""



         __lowerCamelCase          =  parent
         __lowerCamelCase          =  batch_size
         __lowerCamelCase          =  image_size
         __lowerCamelCase          =  patch_sizes
         __lowerCamelCase          =  patch_stride
         __lowerCamelCase          =  patch_padding
         __lowerCamelCase          =  is_training
         __lowerCamelCase          =  use_labels
         __lowerCamelCase          =  num_labels
         __lowerCamelCase          =  num_channels
         __lowerCamelCase          =  embed_dim
         __lowerCamelCase          =  num_heads
         __lowerCamelCase          =  stride_kv
         __lowerCamelCase          =  depth
         __lowerCamelCase          =  cls_token
         __lowerCamelCase          =  attention_drop_rate
         __lowerCamelCase          =  initializer_range
         __lowerCamelCase          =  layer_norm_eps






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         __lowerCamelCase          =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

         __lowerCamelCase          =  None
         if self.use_labels:
             # create a random int32 tensor of given shape
             __lowerCamelCase          =  ids_tensor([self.batch_size]  ,    self.num_labels   )

         __lowerCamelCase          =  self.get_config()
         return config, pixel_values, labels






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         return CvtConfig(
             image_size=self.image_size  ,    num_labels=self.num_labels  ,    num_channels=self.num_channels  ,    embed_dim=self.embed_dim  ,    num_heads=self.num_heads  ,    patch_sizes=self.patch_sizes  ,    patch_padding=self.patch_padding  ,    patch_stride=self.patch_stride  ,    stride_kv=self.stride_kv  ,    depth=self.depth  ,    cls_token=self.cls_token  ,    attention_drop_rate=self.attention_drop_rate  ,    initializer_range=self.initializer_range  ,    )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]  ,    a		:		Dict  ,    a		:		int  ,    a		:		Dict   ):





         """simple docstring"""



         __lowerCamelCase          =  TFCvtModel(config=a   )
         __lowerCamelCase          =  model(a  ,    training=a   )
         __lowerCamelCase          =  (self.image_size, self.image_size)
         __lowerCamelCase     ,  __lowerCamelCase          =  image_size[0], image_size[1]
         for i in range(len(self.depth   )   ):
             __lowerCamelCase          =  floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1   )
             __lowerCamelCase          =  floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1   )
         self.parent.assertEqual(result.last_hidden_state.shape  ,    (self.batch_size, self.embed_dim[-1], height, width)   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		int  ,    a		:		Dict  ,    a		:		Tuple  ,    a		:		List[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.num_labels
         __lowerCamelCase          =  TFCvtForImageClassification(a   )
         __lowerCamelCase          =  model(a  ,    labels=a  ,    training=a   )
         self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.num_labels)   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         __lowerCamelCase          =  self.prepare_config_and_inputs()
         __lowerCamelCase     ,  __lowerCamelCase     ,  __lowerCamelCase          =  config_and_inputs
         __lowerCamelCase          =  {'''pixel_values''': pixel_values}
         return config, inputs_dict




@require_tf
class    a__				(       UpperCAmelCase__							,       UpperCAmelCase__							,       unittest.TestCase			):
     lowerCamelCase  :					Union[str, Any]							=(TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
     lowerCamelCase  :					Optional[int]							=(
         {"feature-extraction": TFCvtModel, "image-classification": TFCvtForImageClassification}
         if is_tf_available()
         else {}
     )
     lowerCamelCase  :					Optional[Any]							=False
     lowerCamelCase  :					int							=False
     lowerCamelCase  :					Any							=False
     lowerCamelCase  :					List[Any]							=False
     lowerCamelCase  :					Union[str, Any]							=False






     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         __lowerCamelCase          =  TFCvtModelTester(self   )
         __lowerCamelCase          =  TFCvtConfigTester(self  ,    config_class=a  ,    has_text_modality=a  ,    hidden_size=37   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         self.config_tester.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()






     @unittest.skip(reason='''Cvt does not output attentions'''   )
     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         pass






     @unittest.skip(reason='''Cvt does not use inputs_embeds'''   )
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         pass






     @unittest.skip(reason='''Cvt does not support input and output embeddings'''   )
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         pass






     @unittest.skipIf(
         not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''   )   ) == 0  ,    reason='''TF does not support backprop for grouped convolutions on CPU.'''  ,    )
     def        SCREAMING_SNAKE_CASE__       (			self		:		Tuple   ):





         """simple docstring"""



         super().test_dataset_conversion()






     @unittest.skipIf(
         not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''   )   ) == 0  ,    reason='''TF does not support backprop for grouped convolutions on CPU.'''  ,    )
     @slow
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         super().test_keras_fit()






     @unittest.skip(reason='''Get `Failed to determine best cudnn convolution algo.` error after using TF 2.12+cuda 11.8'''   )
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         __lowerCamelCase          =  tf.keras.mixed_precision.Policy('''mixed_float16'''   )
         tf.keras.mixed_precision.set_global_policy(a   )
         super().test_keras_fit()
         tf.keras.mixed_precision.set_global_policy('''float32'''   )






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





         """simple docstring"""



         __lowerCamelCase     ,  __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             __lowerCamelCase          =  model_class(a   )
             __lowerCamelCase          =  inspect.signature(model.call   )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             __lowerCamelCase          =  [*signature.parameters.keys()]

             __lowerCamelCase          =  ['''pixel_values''']
             self.assertListEqual(arg_names[:1]  ,    a   )






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





         """simple docstring"""



         def check_hidden_states_output(a		:		str  ,    a		:		Tuple  ,    a		:		Optional[int]   ):
             __lowerCamelCase          =  model_class(a   )

             __lowerCamelCase          =  model(**self._prepare_for_class(a  ,    a   )   )
             __lowerCamelCase          =  outputs.hidden_states

             __lowerCamelCase          =  len(self.model_tester.depth   )
             self.assertEqual(len(a   )  ,    a   )

             # verify the first hidden states (first block)
             self.assertListEqual(
                 list(hidden_states[0].shape[-3:]   )  ,    [
                     self.model_tester.embed_dim[0],
                     self.model_tester.image_size // 4,
                     self.model_tester.image_size // 4,
                 ]  ,    )

         __lowerCamelCase     ,  __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             __lowerCamelCase          =  True
             check_hidden_states_output(a  ,    a  ,    a   )

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             __lowerCamelCase          =  True

             check_hidden_states_output(a  ,    a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*a   )






     @slow
     def        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __lowerCamelCase          =  TFCvtModel.from_pretrained(a   )
             self.assertIsNotNone(a   )






def __lowerCAmelCase			(							)     ->   Any:
    __lowerCamelCase          =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
    return image




@require_tf
@require_vision
class    a__				(       unittest.TestCase			):






     @cached_property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )






     @slow
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )

         __lowerCamelCase          =  self.default_image_processor
         __lowerCamelCase          =  prepare_img()
         __lowerCamelCase          =  image_processor(images=a  ,    return_tensors='''tf'''   )

         # forward pass
         __lowerCamelCase          =  model(**a   )

         # verify the logits
         __lowerCamelCase          =  tf.TensorShape((1, 10_00)   )
         self.assertEqual(outputs.logits.shape  ,    a   )

         __lowerCamelCase          =  tf.constant([0.92_85, 0.90_15, -0.31_50]   )
         self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()  ,    a  ,    atol=1e-4   )   )

'''simple docstring'''




import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCAmelCase												=get_tests_dir("fixtures/spiece.model")




@require_sentencepiece
@require_tokenizers
class    a__				(       UpperCAmelCase__							,       unittest.TestCase			):
     lowerCamelCase  :					Optional[Any]							=DebertaVaTokenizer
     lowerCamelCase  :					Optional[int]							=DebertaVaTokenizerFast
     lowerCamelCase  :					Optional[Any]							=True
     lowerCamelCase  :					Tuple							=True






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         super().setUp()

         # We have a SentencePiece fixture for testing
         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    unk_token='''<unk>'''   )
         tokenizer.save_pretrained(self.tmpdirname   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]  ,    a		:		Dict   ):





         """simple docstring"""



         __lowerCamelCase          =  '''this is a test'''
         __lowerCamelCase          =  '''this is a test'''
         return input_text, output_text






     def        SCREAMING_SNAKE_CASE__       (			self		:		List[str]   ):





         """simple docstring"""



         __lowerCamelCase          =  '''<pad>'''
         __lowerCamelCase          =  0

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






     def        SCREAMING_SNAKE_CASE__       (			self		:		List[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  list(self.get_tokenizer().get_vocab().keys()   )
         self.assertEqual(vocab_keys[0]  ,    '''<pad>'''   )
         self.assertEqual(vocab_keys[1]  ,    '''<unk>'''   )
         self.assertEqual(vocab_keys[-1]  ,    '''[PAD]'''   )
         self.assertEqual(len(a   )  ,    3_00_01   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		int   ):





         """simple docstring"""



         self.assertEqual(self.get_tokenizer().vocab_size  ,    3_00_00   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  ''' \tHeLLo!how  \n Are yoU?  '''
         __lowerCamelCase          =  ['''▁hello''', '''!''', '''how''', '''▁are''', '''▁you''', '''?''']
         # fmt: on

         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    do_lower_case=a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  DebertaVaTokenizerFast(a  ,    do_lower_case=a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )






     @unittest.skip('''There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'''   )
     def        SCREAMING_SNAKE_CASE__       (			self		:		Dict   ):





         """simple docstring"""



         pass






     @unittest.skip('''There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'''   )
     def        SCREAMING_SNAKE_CASE__       (			self		:		List[Any]   ):





         """simple docstring"""



         pass






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





         """simple docstring"""



         __lowerCamelCase          =  '''I was born in 92000, and this is falsé.'''
         __lowerCamelCase          =  ['''▁''', '''<unk>''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', '''▁''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''▁''', '''.''', ]
         # fmt: on

         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    split_by_punct=a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  DebertaVaTokenizerFast(a  ,    split_by_punct=a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         __lowerCamelCase          =  '''I was born in 92000, and this is falsé.'''
         __lowerCamelCase          =  ['''▁i''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', '''▁''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''▁''', '''.''', ]
         # fmt: on

         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(tokenizer.encode(a  ,    add_special_tokens=a   )   )
         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  DebertaVaTokenizerFast(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(a  ,    add_special_tokens=a   )   )
         self.assertListEqual(a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         __lowerCamelCase          =  '''I was born in 92000, and this is falsé.'''
         __lowerCamelCase          =  ['''▁i''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''.''', ]
         # fmt: on

         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  DebertaVaTokenizerFast(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  '''I was born in 92000, and this is falsé.'''
         __lowerCamelCase          =  ['''▁''', '''<unk>''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', '''▁''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''▁''', '''.''', ]
         # fmt: on

         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  DebertaVaTokenizerFast(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  ''' \tHeLLo!how  \n Are yoU?  '''
         __lowerCamelCase          =  ['''▁''', '''<unk>''', '''e''', '''<unk>''', '''o''', '''!''', '''how''', '''▁''', '''<unk>''', '''re''', '''▁yo''', '''<unk>''', '''?''']
         # fmt: on

         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  DebertaVaTokenizerFast(a  ,    do_lower_case=a  ,    split_by_punct=a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(a  ,    add_special_tokens=a   )   )

         self.assertListEqual(a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.get_tokenizer()
         __lowerCamelCase          =  self.get_rust_tokenizer()

         __lowerCamelCase          =  '''I was born in 92000, and this is falsé.'''

         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(tokenizer.encode(a  ,    add_special_tokens=a   )   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(a  ,    add_special_tokens=a   )   )
         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  tokenizer.encode(a  ,    add_special_tokens=a   )
         __lowerCamelCase          =  rust_tokenizer.encode(a  ,    add_special_tokens=a   )
         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  self.get_rust_tokenizer()
         __lowerCamelCase          =  tokenizer.encode(a   )
         __lowerCamelCase          =  rust_tokenizer.encode(a   )
         self.assertListEqual(a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  '''This is a test'''
         __lowerCamelCase          =  [13, 1, 43_98, 25, 21, 12_89]
         __lowerCamelCase          =  ['''▁''', '''T''', '''his''', '''▁is''', '''▁a''', '''▁test''']
         __lowerCamelCase          =  ['''▁''', '''<unk>''', '''his''', '''▁is''', '''▁a''', '''▁test''']

         __lowerCamelCase          =  DebertaVaTokenizer(a  ,    keep_accents=a   )
         __lowerCamelCase          =  DebertaVaTokenizerFast(a  ,    keep_accents=a   )

         __lowerCamelCase          =  tokenizer.encode(a  ,    add_special_tokens=a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  tokenizer.tokenize(a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(a   )
         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  rust_tokenizer.encode(a  ,    add_special_tokens=a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  rust_tokenizer.tokenize(a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(a   )
         self.assertListEqual(a  ,    a   )

         # fmt: off
         __lowerCamelCase          =  '''I was born in 92000, and this is falsé.'''
         __lowerCamelCase          =  [13, 1, 23, 3_86, 19, 5_61, 30_50, 15, 17, 48, 25, 82_56, 18, 1, 9]
         __lowerCamelCase          =  ['''▁''', '''I''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''é''', '''.''', ]
         __lowerCamelCase          =  ['''▁''', '''<unk>''', '''▁was''', '''▁born''', '''▁in''', '''▁9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''.''', ]
         # fmt: on

         __lowerCamelCase          =  tokenizer.encode(a  ,    add_special_tokens=a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  tokenizer.tokenize(a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  tokenizer.convert_ids_to_tokens(a   )
         self.assertListEqual(a  ,    a   )

         __lowerCamelCase          =  rust_tokenizer.encode(a  ,    add_special_tokens=a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  rust_tokenizer.tokenize(a   )
         self.assertListEqual(a  ,    a   )
         __lowerCamelCase          =  rust_tokenizer.convert_ids_to_tokens(a   )
         self.assertListEqual(a  ,    a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         __lowerCamelCase          =  DebertaVaTokenizer(a   )

         __lowerCamelCase          =  tokenizer.encode('''sequence builders'''   )
         __lowerCamelCase          =  tokenizer.encode('''multi-sequence build'''   )

         __lowerCamelCase          =  tokenizer.build_inputs_with_special_tokens(a   )
         __lowerCamelCase          =  tokenizer.build_inputs_with_special_tokens(a  ,    a   )

         self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]  ,    a   )
         self.assertEqual(
             [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id]  ,    a  ,    )






     @slow
     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]   ):





         """simple docstring"""



         __lowerCamelCase          =  {'''input_ids''': [[1, 3_98_67, 36, 1_93_90, 4_86, 27, 3_50_52, 8_14_36, 18, 6_06_85, 12_25, 7, 3_50_52, 8_14_36, 18, 93_67, 1_68_99, 18, 1_59_37, 53, 5_94, 7_73, 18, 1_62_87, 3_04_65, 36, 1_59_37, 6, 4_11_39, 38, 3_69_79, 6_07_63, 1_91, 6, 3_41_32, 99, 6, 5_05_38, 3_90, 4_32_30, 6, 3_41_32, 27_79, 2_08_50, 14, 6_99, 10_72, 11_94, 36, 3_82, 1_09_01, 53, 7, 6_99, 10_72, 20_84, 36, 2_04_22, 6_30, 53, 19, 1_05, 30_49, 18_96, 10_53, 1_68_99, 15_06, 11, 3_79_78, 42_43, 7, 12_37, 3_18_69, 2_00, 1_65_66, 6_54, 6, 3_50_52, 8_14_36, 7, 5_56_30, 1_35_93, 4, 2], [1, 26, 1_50_11, 13, 6_67, 8, 10_53, 18, 2_36_11, 12_37, 7_23_56, 1_28_20, 34, 10_41_34, 12_09, 35, 1_33_13, 66_27, 21, 2_02, 3_47, 7, 1_64, 23_99, 11, 46, 44_85, 4, 2, 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, 5, 12_32, 28_64, 1_57_85, 1_49_51, 1_05, 5, 85_81, 12_50, 4, 2, 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]], '''token_type_ids''': [[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, 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, 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]], '''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, 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, 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=a  ,    model_name='''microsoft/deberta-v2-xlarge'''  ,    revision='''ad6e42c1532ddf3a15c39246b63f5559d558b670'''  ,    )
