
import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers.models.esm.modeling_esmfold import EsmForProteinFolding




class 						lowercase__  :
	def __init__(			self							:   Dict       ,   UpperCAmelCase_							:   List[Any]       ,   UpperCAmelCase_							:   str=13       ,   UpperCAmelCase_							:   Any=7       ,   UpperCAmelCase_							:   Union[str, Any]=False       ,   UpperCAmelCase_							:   Any=True       ,   UpperCAmelCase_							:   List[Any]=False       ,   UpperCAmelCase_							:   Any=False       ,   UpperCAmelCase_							:   int=19       ,   UpperCAmelCase_							:   Tuple=32       ,   UpperCAmelCase_							:   Optional[int]=5       ,   UpperCAmelCase_							:   Tuple=4       ,   UpperCAmelCase_							:   Dict=37       ,   UpperCAmelCase_							:   Any="gelu"       ,   UpperCAmelCase_							:   List[Any]=0.1       ,   UpperCAmelCase_							:   int=0.1       ,   UpperCAmelCase_							:   List[Any]=512       ,   UpperCAmelCase_							:   int=16       ,   UpperCAmelCase_							:   Optional[Any]=2       ,   UpperCAmelCase_							:   Any=0.02       ,   UpperCAmelCase_							:   Tuple=3       ,   UpperCAmelCase_							:   Union[str, Any]=4       ,   UpperCAmelCase_							:   List[str]=None       ,   ):
						SCREAMING_SNAKE_CASE__													= parent
						SCREAMING_SNAKE_CASE__													= batch_size
						SCREAMING_SNAKE_CASE__													= seq_length
						SCREAMING_SNAKE_CASE__													= is_training
						SCREAMING_SNAKE_CASE__													= use_input_mask
						SCREAMING_SNAKE_CASE__													= use_token_type_ids
						SCREAMING_SNAKE_CASE__													= use_labels
						SCREAMING_SNAKE_CASE__													= vocab_size
						SCREAMING_SNAKE_CASE__													= hidden_size
						SCREAMING_SNAKE_CASE__													= num_hidden_layers
						SCREAMING_SNAKE_CASE__													= num_attention_heads
						SCREAMING_SNAKE_CASE__													= intermediate_size
						SCREAMING_SNAKE_CASE__													= hidden_act
						SCREAMING_SNAKE_CASE__													= hidden_dropout_prob
						SCREAMING_SNAKE_CASE__													= attention_probs_dropout_prob
						SCREAMING_SNAKE_CASE__													= max_position_embeddings
						SCREAMING_SNAKE_CASE__													= type_vocab_size
						SCREAMING_SNAKE_CASE__													= type_sequence_label_size
						SCREAMING_SNAKE_CASE__													= initializer_range
						SCREAMING_SNAKE_CASE__													= num_labels
						SCREAMING_SNAKE_CASE__													= num_choices
						SCREAMING_SNAKE_CASE__													= scope
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= ids_tensor([self.batch_size, self.seq_length]       ,   self.vocab_size							)

						SCREAMING_SNAKE_CASE__													= None
						if self.use_input_mask:
											SCREAMING_SNAKE_CASE__													= random_attention_mask([self.batch_size, self.seq_length]							)

						SCREAMING_SNAKE_CASE__													= None
						SCREAMING_SNAKE_CASE__													= None
						SCREAMING_SNAKE_CASE__													= None
						if self.use_labels:
											SCREAMING_SNAKE_CASE__													= ids_tensor([self.batch_size]       ,   self.type_sequence_label_size							)
											SCREAMING_SNAKE_CASE__													= ids_tensor([self.batch_size, self.seq_length]       ,   self.num_labels							)
											SCREAMING_SNAKE_CASE__													= ids_tensor([self.batch_size]       ,   self.num_choices							)

						SCREAMING_SNAKE_CASE__													= self.get_config()

						return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= EsmConfig(
						    vocab_size=33       ,   hidden_size=self.hidden_size       ,   pad_token_id=1       ,   num_hidden_layers=self.num_hidden_layers       ,   num_attention_heads=self.num_attention_heads       ,   intermediate_size=self.intermediate_size       ,   hidden_act=self.hidden_act       ,   hidden_dropout_prob=self.hidden_dropout_prob       ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,   max_position_embeddings=self.max_position_embeddings       ,   type_vocab_size=self.type_vocab_size       ,   initializer_range=self.initializer_range       ,   is_folding_model=UpperCAmelCase_       ,   esmfold_config={'trunk': {'num_blocks': 2}, 'fp16_esm': False}       ,   )
						return config
	def      A_				(			self							:   List[str]       ,   UpperCAmelCase_							:   Union[str, Any]       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   int       ,   UpperCAmelCase_							:   str       ,   UpperCAmelCase_							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= EsmForProteinFolding(config=UpperCAmelCase_							).float()
						model.to(UpperCAmelCase_							)
						model.eval()
						SCREAMING_SNAKE_CASE__													= model(UpperCAmelCase_       ,   attention_mask=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= model(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= model(UpperCAmelCase_							)

						self.parent.assertEqual(result.positions.shape       ,   (8, self.batch_size, self.seq_length, 14, 3)							)
						self.parent.assertEqual(result.angles.shape       ,   (8, self.batch_size, self.seq_length, 7, 2)							)





	def      A_				(			self							:   Dict							):
						SCREAMING_SNAKE_CASE__													= self.prepare_config_and_inputs()
						(
						    (
						    SCREAMING_SNAKE_CASE__
						)						, (
						    SCREAMING_SNAKE_CASE__
						)						, (
						    SCREAMING_SNAKE_CASE__
						)						, (
						    SCREAMING_SNAKE_CASE__
						)						, (
						    SCREAMING_SNAKE_CASE__
						)						, (
						    SCREAMING_SNAKE_CASE__
						)						, 
						)													= config_and_inputs
						SCREAMING_SNAKE_CASE__													= {'input_ids': input_ids, 'attention_mask': input_mask}
						return config, inputs_dict





@require_torch
class 						lowercase__  (						_UpperCAmelCase     ,       _UpperCAmelCase     ,       unittest.TestCase  ):
	A__    :   List[Any]				       =False

	A__    :   int				       =(EsmForProteinFolding,) if is_torch_available() else ()
	A__    :   List[str]				       =()
	A__    :   int				       ={} if is_torch_available() else {}
	A__    :   int				       =False
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= EsmFoldModelTester(self							)
						SCREAMING_SNAKE_CASE__													= ConfigTester(self       ,   config_class=UpperCAmelCase_       ,   hidden_size=37							)
	def      A_				(			self							:   List[str]							):
						self.config_tester.run_common_tests()
	def      A_				(			self							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCAmelCase_							)
	@unittest.skip('Does not support attention outputs'							)
	def      A_				(			self							:   Tuple							):
						pass
	@unittest.skip
	def      A_				(			self							:   Any							):
						pass
	@unittest.skip('Esm does not support embedding resizing'							)
	def      A_				(			self							:   str							):
						pass
	@unittest.skip('Esm does not support embedding resizing'							)
	def      A_				(			self							:   int							):
						pass
	@unittest.skip('ESMFold does not support passing input embeds!'							)
	def      A_				(			self							:   Union[str, Any]							):
						pass
	@unittest.skip('ESMFold does not support head pruning.'							)
	def      A_				(			self							:   Any							):
						pass
	@unittest.skip('ESMFold does not support head pruning.'							)
	def      A_				(			self							:   str							):
						pass
	@unittest.skip('ESMFold does not support head pruning.'							)
	def      A_				(			self							:   str							):
						pass
	@unittest.skip('ESMFold does not support head pruning.'							)
	def      A_				(			self							:   str							):
						pass
	@unittest.skip('ESMFold does not support head pruning.'							)
	def      A_				(			self							:   Tuple							):
						pass
	@unittest.skip('ESMFold does not output hidden states in the normal way.'							)
	def      A_				(			self							:   Optional[Any]							):
						pass
	@unittest.skip('ESMfold does not output hidden states in the normal way.'							)
	def      A_				(			self							:   Optional[Any]							):
						pass
	@unittest.skip('ESMFold only has one output format.'							)
	def      A_				(			self							:   int							):
						pass
	@unittest.skip('This test doesn\'t work for ESMFold and doesn\'t test core functionality'							)
	def      A_				(			self							:   Optional[Any]							):
						pass
	@unittest.skip('ESMFold does not support input chunking.'							)
	def      A_				(			self							:   Optional[Any]							):
						pass
	@unittest.skip('ESMFold doesn\'t respect you and it certainly doesn\'t respect your initialization arguments.'							)
	def      A_				(			self							:   Tuple							):
						pass
	@unittest.skip('ESMFold doesn\'t support torchscript compilation.'							)
	def      A_				(			self							:   Dict							):
						pass
	@unittest.skip('ESMFold doesn\'t support torchscript compilation.'							)
	def      A_				(			self							:   List[str]							):
						pass
	@unittest.skip('ESMFold doesn\'t support torchscript compilation.'							)
	def      A_				(			self							:   str							):
						pass
	@unittest.skip('ESMFold doesn\'t support data parallel.'							)
	def      A_				(			self							:   Optional[Any]							):
						pass





	@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'							)
	def      A_				(			self							:   Union[str, Any]							):
						pass





@require_torch
class 						lowercase__  (						_UpperCAmelCase  ):
	@slow
	def      A_				(			self							:   str							):
						SCREAMING_SNAKE_CASE__													= EsmForProteinFolding.from_pretrained('facebook/esmfold_v1'							).float()
						model.eval()
						SCREAMING_SNAKE_CASE__													= torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]							)
						SCREAMING_SNAKE_CASE__													= model(UpperCAmelCase_							)['positions']
						SCREAMING_SNAKE_CASE__													= torch.tensor([2.5_828, 0.7_993, -10.9_334]       ,   dtype=torch.floataa							)
						self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]       ,   UpperCAmelCase_       ,   atol=1e-4							)							)







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


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




@require_sentencepiece
@require_tokenizers
class 						lowercase__  (						_UpperCAmelCase     ,       unittest.TestCase  ):
	A__    :   str				       =DebertaVaTokenizer
	A__    :   List[str]				       =DebertaVaTokenizerFast
	A__    :   Any				       =True
	A__    :   str				       =True
	def      A_				(			self							:   Tuple							):
						super().setUp()

						# We have a SentencePiece fixture for testing
						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   unk_token='<unk>'							)
						tokenizer.save_pretrained(self.tmpdirname							)
	def      A_				(			self							:   Union[str, Any]       ,   UpperCAmelCase_							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= 'this is a test'
						SCREAMING_SNAKE_CASE__													= 'this is a test'
						return input_text, output_text
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= '<pad>'
						SCREAMING_SNAKE_CASE__													= 0

						self.assertEqual(self.get_tokenizer()._convert_token_to_id(UpperCAmelCase_							)       ,   UpperCAmelCase_							)
						self.assertEqual(self.get_tokenizer()._convert_id_to_token(UpperCAmelCase_							)       ,   UpperCAmelCase_							)
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= 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(UpperCAmelCase_							)       ,   30001							)
	def      A_				(			self							:   str							):
						self.assertEqual(self.get_tokenizer().vocab_size       ,   30000							)
	def      A_				(			self							:   Optional[Any]							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= ' \tHeLLo!how  \n Are yoU?  '
						SCREAMING_SNAKE_CASE__													= ['▁hello', '!', 'how', '▁are', '▁you', '?']
						# fmt: on

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizerFast(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'							)
	def      A_				(			self							:   Any							):
						pass
	@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'							)
	def      A_				(			self							:   Tuple							):
						pass
	def      A_				(			self							:   List[str]							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= 'I was born in 92000, and this is falsé.'
						SCREAMING_SNAKE_CASE__													= ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
						# fmt: on

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizerFast(UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   List[str]							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= 'I was born in 92000, and this is falsé.'
						SCREAMING_SNAKE_CASE__													= ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
						# fmt: on

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizerFast(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   int							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= 'I was born in 92000, and this is falsé.'
						SCREAMING_SNAKE_CASE__													= ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
						# fmt: on

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizerFast(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   Tuple							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= 'I was born in 92000, and this is falsé.'
						SCREAMING_SNAKE_CASE__													= ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
						# fmt: on

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizerFast(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   Any							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= ' \tHeLLo!how  \n Are yoU?  '
						SCREAMING_SNAKE_CASE__													= ['▁', '<unk>', 'e', '<unk>', 'o', '!', 'how', '▁', '<unk>', 're', '▁yo', '<unk>', '?']
						# fmt: on

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizerFast(UpperCAmelCase_       ,   do_lower_case=UpperCAmelCase_       ,   split_by_punct=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)

						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   int							):
						SCREAMING_SNAKE_CASE__													= self.get_tokenizer()
						SCREAMING_SNAKE_CASE__													= self.get_rust_tokenizer()

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

						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= self.get_rust_tokenizer()
						SCREAMING_SNAKE_CASE__													= tokenizer.encode(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.encode(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= 'This is a test'
						SCREAMING_SNAKE_CASE__													= [13, 1, 4398, 25, 21, 1289]
						SCREAMING_SNAKE_CASE__													= ['▁', 'T', 'his', '▁is', '▁a', '▁test']
						SCREAMING_SNAKE_CASE__													= ['▁', '<unk>', 'his', '▁is', '▁a', '▁test']

						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_       ,   keep_accents=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizerFast(UpperCAmelCase_       ,   keep_accents=UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.tokenize(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.tokenize(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						# fmt: off
						SCREAMING_SNAKE_CASE__													= 'I was born in 92000, and this is falsé.'
						SCREAMING_SNAKE_CASE__													= [13, 1, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]
						SCREAMING_SNAKE_CASE__													= ['▁', 'I', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.', ]
						SCREAMING_SNAKE_CASE__													= ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
						# fmt: on

						SCREAMING_SNAKE_CASE__													= tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.tokenize(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_ids_to_tokens(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						SCREAMING_SNAKE_CASE__													= rust_tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.tokenize(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= rust_tokenizer.convert_ids_to_tokens(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= DebertaVaTokenizer(UpperCAmelCase_							)

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

						SCREAMING_SNAKE_CASE__													= tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_       ,   UpperCAmelCase_							)

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





	@slow
	def      A_				(			self							:   Optional[Any]							):
						# fmt: off
						SCREAMING_SNAKE_CASE__													= {'input_ids': [[1, 39867, 36, 19390, 486, 27, 35052, 81436, 18, 60685, 1225, 7, 35052, 81436, 18, 9367, 16899, 18, 15937, 53, 594, 773, 18, 16287, 30465, 36, 15937, 6, 41139, 38, 36979, 60763, 191, 6, 34132, 99, 6, 50538, 390, 43230, 6, 34132, 2779, 20850, 14, 699, 1072, 1194, 36, 382, 10901, 53, 7, 699, 1072, 2084, 36, 20422, 630, 53, 19, 105, 3049, 1896, 1053, 16899, 1506, 11, 37978, 4243, 7, 1237, 31869, 200, 16566, 654, 6, 35052, 81436, 7, 55630, 13593, 4, 2], [1, 26, 15011, 13, 667, 8, 1053, 18, 23611, 1237, 72356, 12820, 34, 104134, 1209, 35, 13313, 6627, 21, 202, 347, 7, 164, 2399, 11, 46, 4485, 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, 1232, 2864, 15785, 14951, 105, 5, 8581, 1250, 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=UpperCAmelCase_       ,   model_name='microsoft/deberta-v2-xlarge'       ,   revision='ad6e42c1532ddf3a15c39246b63f5559d558b670'       ,   )





