



import unittest

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

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


if is_torch_available():
	import torch

	from transformers import (
	    RemBertConfig,
	    RemBertForCausalLM,
	    RemBertForMaskedLM,
	    RemBertForMultipleChoice,
	    RemBertForQuestionAnswering,
	    RemBertForSequenceClassification,
	    RemBertForTokenClassification,
	    RemBertModel,
	)
	from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST


class  _lowercase				:
				'''simple docstring'''







				def __init__(	self       ,	snake_case__       ,	snake_case__=13       ,	snake_case__=7       ,	snake_case__=True       ,	snake_case__=True       ,	snake_case__=True       ,	snake_case__=True       ,	snake_case__=99       ,	snake_case__=32       ,	snake_case__=18       ,	snake_case__=43       ,	snake_case__=5       ,	snake_case__=4       ,	snake_case__=37       ,	snake_case__="gelu"       ,	snake_case__=0.1       ,	snake_case__=0.1       ,	snake_case__=512       ,	snake_case__=16       ,	snake_case__=2       ,	snake_case__=0.02       ,	snake_case__=3       ,	snake_case__=4       ,	snake_case__=None       ,	):

									'''simple docstring'''


									UpperCamelCase_											=				parent
									UpperCamelCase_											=				batch_size
									UpperCamelCase_											=				seq_length
									UpperCamelCase_											=				is_training
									UpperCamelCase_											=				use_input_mask
									UpperCamelCase_											=				use_token_type_ids
									UpperCamelCase_											=				use_labels
									UpperCamelCase_											=				vocab_size
									UpperCamelCase_											=				hidden_size
									UpperCamelCase_											=				input_embedding_size
									UpperCamelCase_											=				output_embedding_size
									UpperCamelCase_											=				num_hidden_layers
									UpperCamelCase_											=				num_attention_heads
									UpperCamelCase_											=				intermediate_size
									UpperCamelCase_											=				hidden_act
									UpperCamelCase_											=				hidden_dropout_prob
									UpperCamelCase_											=				attention_probs_dropout_prob
									UpperCamelCase_											=				max_position_embeddings
									UpperCamelCase_											=				type_vocab_size
									UpperCamelCase_											=				type_sequence_label_size
									UpperCamelCase_											=				initializer_range
									UpperCamelCase_											=				num_labels
									UpperCamelCase_											=				num_choices
									UpperCamelCase_											=				scope

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				ids_tensor([self.batch_size, self.seq_length]       ,	self.vocab_size      )

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

									UpperCamelCase_											=				None
									if self.use_token_type_ids:
														UpperCamelCase_											=				ids_tensor([self.batch_size, self.seq_length]       ,	self.type_vocab_size      )

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

									UpperCamelCase_											=				RemBertConfig(
									    vocab_size=self.vocab_size       ,	hidden_size=self.hidden_size       ,	input_embedding_size=self.input_embedding_size       ,	output_embedding_size=self.output_embedding_size       ,	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       ,	is_decoder=snake_case__       ,	initializer_range=self.initializer_range       ,	)

									return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									(
									    (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      
									)											=				self.prepare_config_and_inputs()

									UpperCamelCase_											=				True
									UpperCamelCase_											=				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]      )
									UpperCamelCase_											=				ids_tensor([self.batch_size, self.seq_length]       ,	vocab_size=2      )

									return (
									    config,
									    input_ids,
									    token_type_ids,
									    input_mask,
									    sequence_labels,
									    token_labels,
									    choice_labels,
									    encoder_hidden_states,
									    encoder_attention_mask,
									)

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				RemBertModel(config=snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				model(snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__      )
									UpperCamelCase_											=				model(snake_case__       ,	token_type_ids=snake_case__      )
									UpperCamelCase_											=				model(snake_case__      )
									self.parent.assertEqual(result.last_hidden_state.shape       ,	(self.batch_size, self.seq_length, self.hidden_size)      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	):

									'''simple docstring'''


									UpperCamelCase_											=				True
									UpperCamelCase_											=				RemBertModel(snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				model(
									    snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	encoder_hidden_states=snake_case__       ,	encoder_attention_mask=snake_case__       ,	)
									UpperCamelCase_											=				model(
									    snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	encoder_hidden_states=snake_case__       ,	)
									UpperCamelCase_											=				model(snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__      )
									self.parent.assertEqual(result.last_hidden_state.shape       ,	(self.batch_size, self.seq_length, self.hidden_size)      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	):

									'''simple docstring'''


									UpperCamelCase_											=				RemBertForCausalLM(config=snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				model(snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	labels=snake_case__      )
									self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.vocab_size)      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				RemBertForMaskedLM(config=snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				model(snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	labels=snake_case__      )
									self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.vocab_size)      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	):

									'''simple docstring'''


									UpperCamelCase_											=				True
									UpperCamelCase_											=				True
									UpperCamelCase_											=				RemBertForCausalLM(config=snake_case__      )
									model.to(snake_case__      )
									model.eval()

									# first forward pass
									UpperCamelCase_											=				model(
									    snake_case__       ,	attention_mask=snake_case__       ,	encoder_hidden_states=snake_case__       ,	encoder_attention_mask=snake_case__       ,	use_cache=snake_case__       ,	)
									UpperCamelCase_											=				outputs.past_key_values

									# create hypothetical multiple next token and extent to next_input_ids
									UpperCamelCase_											=				ids_tensor((self.batch_size, 3)       ,	config.vocab_size      )
									UpperCamelCase_											=				ids_tensor((self.batch_size, 3)       ,	vocab_size=2      )

									# append to next input_ids and
									UpperCamelCase_											=				torch.cat([input_ids, next_tokens]       ,	dim=-1      )
									UpperCamelCase_											=				torch.cat([input_mask, next_mask]       ,	dim=-1      )

									UpperCamelCase_											=				model(
									    snake_case__       ,	attention_mask=snake_case__       ,	encoder_hidden_states=snake_case__       ,	encoder_attention_mask=snake_case__       ,	output_hidden_states=snake_case__       ,	)["hidden_states"][0]
									UpperCamelCase_											=				model(
									    snake_case__       ,	attention_mask=snake_case__       ,	encoder_hidden_states=snake_case__       ,	encoder_attention_mask=snake_case__       ,	past_key_values=snake_case__       ,	output_hidden_states=snake_case__       ,	)["hidden_states"][0]

									# select random slice
									UpperCamelCase_											=				ids_tensor((1,)       ,	output_from_past.shape[-1]      ).item()
									UpperCamelCase_											=				output_from_no_past[:, -3:, random_slice_idx].detach()
									UpperCamelCase_											=				output_from_past[:, :, random_slice_idx].detach()

									self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]      )

									# test that outputs are equal for slice
									self.parent.assertTrue(torch.allclose(snake_case__       ,	snake_case__       ,	atol=1e-3      )      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				RemBertForQuestionAnswering(config=snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				model(
									    snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	start_positions=snake_case__       ,	end_positions=snake_case__       ,	)
									self.parent.assertEqual(result.start_logits.shape       ,	(self.batch_size, self.seq_length)      )
									self.parent.assertEqual(result.end_logits.shape       ,	(self.batch_size, self.seq_length)      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.num_labels
									UpperCamelCase_											=				RemBertForSequenceClassification(snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				model(snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	labels=snake_case__      )
									self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_labels)      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.num_labels
									UpperCamelCase_											=				RemBertForTokenClassification(config=snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				model(snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	labels=snake_case__      )
									self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.num_labels)      )

				def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.num_choices
									UpperCamelCase_											=				RemBertForMultipleChoice(config=snake_case__      )
									model.to(snake_case__      )
									model.eval()
									UpperCamelCase_											=				input_ids.unsqueeze(1      ).expand(-1       ,	self.num_choices       ,	-1      ).contiguous()
									UpperCamelCase_											=				token_type_ids.unsqueeze(1      ).expand(-1       ,	self.num_choices       ,	-1      ).contiguous()
									UpperCamelCase_											=				input_mask.unsqueeze(1      ).expand(-1       ,	self.num_choices       ,	-1      ).contiguous()
									UpperCamelCase_											=				model(
									    snake_case__       ,	attention_mask=snake_case__       ,	token_type_ids=snake_case__       ,	labels=snake_case__       ,	)
									self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_choices)      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.prepare_config_and_inputs()
									(
									    (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      
									)											=				config_and_inputs
									UpperCamelCase_											=				{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
									return config, inputs_dict




@require_torch
class  _lowercase				(a_ ,				a_ ,				unittest.TestCase ):
				'''simple docstring'''







				lowercase__				  =  (
				    (
				        RemBertModel,
				        RemBertForMaskedLM,
				        RemBertForCausalLM,
				        RemBertForMultipleChoice,
				        RemBertForQuestionAnswering,
				        RemBertForSequenceClassification,
				        RemBertForTokenClassification,
				    )
				    if is_torch_available()
				    else ()
				)
				lowercase__				  =  (RemBertForCausalLM,) if is_torch_available() else ()
				lowercase__				  =  (
				    {
				        """feature-extraction""": RemBertModel,
				        """fill-mask""": RemBertForMaskedLM,
				        """question-answering""": RemBertForQuestionAnswering,
				        """text-classification""": RemBertForSequenceClassification,
				        """text-generation""": RemBertForCausalLM,
				        """token-classification""": RemBertForTokenClassification,
				        """zero-shot""": RemBertForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				RemBertModelTester(self      )
									UpperCamelCase_											=				ConfigTester(self       ,	config_class=snake_case__       ,	hidden_size=37      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									self.config_tester.run_common_tests()

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
														UpperCamelCase_											=				type
														self.model_tester.create_and_check_model(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_multiple_choice(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_decoder_model_past_large_inputs(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_model_as_decoder(*snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									(
									    (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      (
									    UpperCamelCase_
									)					,      
									)											=				self.model_tester.prepare_config_and_inputs_for_decoder()

									UpperCamelCase_											=				None

									self.model_tester.create_and_check_model_as_decoder(
									    snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	snake_case__       ,	)

				@slow
				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														UpperCamelCase_											=				RemBertModel.from_pretrained(snake_case__      )
														self.assertIsNotNone(snake_case__      )




@require_torch
class  _lowercase				(unittest.TestCase ):
				'''simple docstring'''







				@slow
				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				RemBertModel.from_pretrained("google/rembert"      )
									UpperCamelCase_											=				torch.tensor([[312, 5_6498, 313, 2125, 313]]      )
									UpperCamelCase_											=				torch.tensor([[0, 0, 0, 1, 1]]      )
									with torch.no_grad():
														UpperCamelCase_											=				model(snake_case__       ,	token_type_ids=snake_case__       ,	output_hidden_states=snake_case__      )

									UpperCamelCase_											=				1152

									UpperCamelCase_											=				torch.Size((1, 5, hidden_size)      )
									self.assertEqual(output["last_hidden_state"].shape       ,	snake_case__      )

									UpperCamelCase_											=				torch.tensor(
									    [
									        [
									            [0.0_754, -0.2_022, 0.1_904],
									            [-0.3_354, -0.3_692, -0.4_791],
									            [-0.2_314, -0.6_729, -0.0_749],
									            [-0.0_396, -0.3_105, -0.4_234],
									            [-0.1_571, -0.0_525, 0.5_353],
									        ]
									    ]      )

									# Running on the original tf implementation gives slightly different results here.
									# Not clear why this variations is present
									# TODO: Find reason for discrepancy
									# expected_original_implementation = [[
									#     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
									#     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
									#     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
									#     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
									#     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
									# ]]

									self.assertTrue(torch.allclose(output["last_hidden_state"][:, :, :3]       ,	snake_case__       ,	atol=1e-4      )      )





from typing import Literal

UpperCAmelCase				:							Tuple								="""ABCDEFGHIJKLMNOPQRSTUVWXYZ"""



def 				_lowerCAmelCase      (_lowerCAmelCase				,		_lowerCAmelCase				,		_lowerCAmelCase):
					UpperCamelCase_											=				LETTERS if mode == "decrypt" else key
					UpperCamelCase_											=				key if mode == "decrypt" else LETTERS
					UpperCamelCase_											=				""
					# loop through each symbol in the message
					for symbol in message:
										if symbol.upper() in chars_a:
															# encrypt/decrypt the symbol
															UpperCamelCase_											=				chars_a.find(symbol.upper())
															if symbol.isupper():
																				translated += chars_b[sym_index].upper()
															else:
																				translated += chars_b[sym_index].lower()
										else:
															# symbol is not in LETTERS, just add it
															translated += symbol
					return translated



def 				_lowerCAmelCase      (_lowerCAmelCase				,		_lowerCAmelCase):
					return translate_message(_lowerCAmelCase				,		_lowerCAmelCase				,		"encrypt")



def 				_lowerCAmelCase      (_lowerCAmelCase				,		_lowerCAmelCase):
					return translate_message(_lowerCAmelCase				,		_lowerCAmelCase				,		"decrypt")



def 				_lowerCAmelCase      ():
					UpperCamelCase_											=				"Hello World"
					UpperCamelCase_											=				"QWERTYUIOPASDFGHJKLZXCVBNM"
					UpperCamelCase_											=				"decrypt"  # set to 'encrypt' or 'decrypt'

					if mode == "encrypt":
										UpperCamelCase_											=				encrypt_message(_lowerCAmelCase				,		_lowerCAmelCase)
					elif mode == "decrypt":
										UpperCamelCase_											=				decrypt_message(_lowerCAmelCase				,		_lowerCAmelCase)
					print(f"""Using the key {key}, the {mode}ed message is: {translated}""")


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()
