





import unittest

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

from ...generation.test_utils import GenerationTesterMixin
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 BertGenerationDecoder, BertGenerationEncoder



class    A__  :





      def __init__(					self			,				A_			,				A_=13			,				A_=7			,				A_=True			,				A_=True			,				A_=99			,				A_=32			,				A_=5			,				A_=4			,				A_=37			,				A_="gelu"			,				A_=0.1			,				A_=0.1			,				A_=50			,				A_=0.02			,				A_=True			,				A_=None			,				):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  parent
       UpperCamelCase      :   Optional[Any]			      =  batch_size
       UpperCamelCase      :   str			      =  seq_length
       UpperCamelCase      :   Union[str, Any]			      =  is_training
       UpperCamelCase      :   int			      =  use_input_mask
       UpperCamelCase      :   List[str]			      =  vocab_size
       UpperCamelCase      :   int			      =  hidden_size
       UpperCamelCase      :   Optional[Any]			      =  num_hidden_layers
       UpperCamelCase      :   Optional[Any]			      =  num_attention_heads
       UpperCamelCase      :   Tuple			      =  intermediate_size
       UpperCamelCase      :   Union[str, Any]			      =  hidden_act
       UpperCamelCase      :   str			      =  hidden_dropout_prob
       UpperCamelCase      :   int			      =  attention_probs_dropout_prob
       UpperCamelCase      :   List[Any]			      =  max_position_embeddings
       UpperCamelCase      :   Any			      =  initializer_range
       UpperCamelCase      :   Any			      =  use_labels
       UpperCamelCase      :   Optional[int]			      =  scope





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Tuple			      =  ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size  )

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

       if self.use_labels:
        UpperCamelCase      :   Union[str, Any]			      =  ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size  )

       UpperCamelCase      :   Union[str, Any]			      =  self.get_config()

       return config, input_ids, input_mask, token_labels





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return BertGenerationConfig(
           vocab_size=self.vocab_size			,				hidden_size=self.hidden_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			,				is_decoder=A_			,				initializer_range=self.initializer_range			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       (
           (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       
       )      :   str			      =  self.prepare_config_and_inputs()

       UpperCamelCase      :   int			      =  True
       UpperCamelCase      :   str			      =  floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
       UpperCamelCase      :   Union[str, Any]			      =  ids_tensor([self.batch_size, self.seq_length]			,				vocab_size=2  )

       return (
           config,
           input_ids,
           input_mask,
           token_labels,
           encoder_hidden_states,
           encoder_attention_mask,
       )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				**A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Tuple			      =  BertGenerationEncoder(config=A_  )
       model.to(A_  )
       model.eval()
       UpperCamelCase      :   Dict			      =  model(A_			,				attention_mask=A_  )
       UpperCamelCase      :   Optional[Any]			      =  model(A_  )
       self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)  )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				**A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  True
       UpperCamelCase      :   List[str]			      =  BertGenerationEncoder(config=A_  )
       model.to(A_  )
       model.eval()
       UpperCamelCase      :   List[str]			      =  model(
           A_			,				attention_mask=A_			,				encoder_hidden_states=A_			,				encoder_attention_mask=A_			,				)
       UpperCamelCase      :   int			      =  model(
           A_			,				attention_mask=A_			,				encoder_hidden_states=A_			,				)
       self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)  )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				**A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  True
       UpperCamelCase      :   Union[str, Any]			      =  True
       UpperCamelCase      :   int			      =  BertGenerationDecoder(config=A_  ).to(A_  ).eval()

       # first forward pass
       UpperCamelCase      :   Optional[Any]			      =  model(
           A_			,				attention_mask=A_			,				encoder_hidden_states=A_			,				encoder_attention_mask=A_			,				use_cache=A_			,				)
       UpperCamelCase      :   Any			      =  outputs.past_key_values

       # create hypothetical multiple next token and extent to next_input_ids
       UpperCamelCase      :   Any			      =  ids_tensor((self.batch_size, 3)			,				config.vocab_size  )
       UpperCamelCase      :   Optional[Any]			      =  ids_tensor((self.batch_size, 3)			,				vocab_size=2  )

       # append to next input_ids and
       UpperCamelCase      :   int			      =  torch.cat([input_ids, next_tokens]			,				dim=-1  )
       UpperCamelCase      :   Union[str, Any]			      =  torch.cat([input_mask, next_mask]			,				dim=-1  )

       UpperCamelCase      :   Dict			      =  model(
           A_			,				attention_mask=A_			,				encoder_hidden_states=A_			,				encoder_attention_mask=A_			,				output_hidden_states=A_			,				)["hidden_states"][0]
       UpperCamelCase      :   Dict			      =  model(
           A_			,				attention_mask=A_			,				encoder_hidden_states=A_			,				encoder_attention_mask=A_			,				past_key_values=A_			,				output_hidden_states=A_			,				)["hidden_states"][0]

       # select random slice
       UpperCamelCase      :   Any			      =  ids_tensor((1,)			,				output_from_past.shape[-1]  ).item()
       UpperCamelCase      :   int			      =  output_from_no_past[:, -3:, random_slice_idx].detach()
       UpperCamelCase      :   Any			      =  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(A_			,				A_			,				atol=1e-3  )  )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_			,				A_			,				*A_			,				):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  BertGenerationDecoder(A_  )
       model.to(A_  )
       model.eval()
       UpperCamelCase      :   Any			      =  model(A_			,				attention_mask=A_			,				labels=A_  )
       self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size)  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      ,       UpperCamelCase      ,       UpperCamelCase      ,       UpperCamelCase      :   Dict			      =  self.prepare_config_and_inputs()
       UpperCamelCase      :   int			      =  {"input_ids": input_ids, "attention_mask": input_mask}
       return config, inputs_dict



@require_torch
class    A__  (			__snake_case			,  __snake_case			,  __snake_case			,  unittest.TestCase     ):
      _UpperCAmelCase      :List[Any]		       =  (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
      _UpperCAmelCase      :Any		       =  (BertGenerationDecoder,) if is_torch_available() else ()
      _UpperCAmelCase      :Tuple		       =  (
          {'feature-extraction': BertGenerationEncoder, 'text-generation': BertGenerationDecoder}
          if is_torch_available()
          else {}
      )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[Any]			      =  BertGenerationEncoderTester(self  )
       UpperCamelCase      :   Dict			      =  ConfigTester(self			,				config_class=A_			,				hidden_size=37  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       self.config_tester.run_common_tests()





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[Any]			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      ,       UpperCamelCase      ,       UpperCamelCase      ,       UpperCamelCase      :   Dict			      =  self.model_tester.prepare_config_and_inputs()
       UpperCamelCase      :   Optional[Any]			      =  "bert"
       self.model_tester.create_and_check_model(A_			,				A_			,				A_			,				A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_model_as_decoder(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   str			      =  self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_decoder_model_past_large_inputs(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       (
           (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       (
           UpperCamelCase
       )      ,       
       )      :   List[str]			      =  self.model_tester.prepare_config_and_inputs_for_decoder()

       UpperCamelCase      :   Optional[Any]			      =  None

       self.model_tester.create_and_check_model_as_decoder(
           A_			,				A_			,				A_			,				A_			,				A_			,				A_			,				)





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_for_causal_lm(*A_  )





      @slow
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"  )
       self.assertIsNotNone(A_  )



@require_torch
class    A__  (			unittest.TestCase     ):





      @slow
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"  )
       UpperCamelCase      :   int			      =  torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 1_0140, 102]]  )
       with torch.no_grad():
        UpperCamelCase      :   int			      =  model(A_  )[0]
       UpperCamelCase      :   Tuple			      =  torch.Size([1, 8, 1024]  )
       self.assertEqual(output.shape			,				A_  )
       UpperCamelCase      :   Tuple			      =  torch.tensor(
           [[[0.17_75, 0.00_83, -0.03_21], [1.60_02, 0.12_87, 0.39_12], [2.14_73, 0.57_91, 0.60_66]]]  )
       self.assertTrue(torch.allclose(output[:, :3, :3]			,				A_			,				atol=1e-4  )  )



@require_torch
class    A__  (			unittest.TestCase     ):





      @slow
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   int			      =  BertGenerationDecoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"  )
       UpperCamelCase      :   Optional[Any]			      =  torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 1_0140, 102]]  )
       with torch.no_grad():
        UpperCamelCase      :   List[str]			      =  model(A_  )[0]
       UpperCamelCase      :   List[str]			      =  torch.Size([1, 8, 5_0358]  )
       self.assertEqual(output.shape			,				A_  )
       UpperCamelCase      :   Optional[int]			      =  torch.tensor(
           [[[-0.57_88, -2.59_94, -3.70_54], [0.04_38, 4.79_97, 1.87_95], [1.58_62, 6.64_09, 4.46_38]]]  )
       self.assertTrue(torch.allclose(output[:, :3, :3]			,				A_			,				atol=1e-4  )  )







def 						A_							(	_lowerCAmelCase	)		->					bool:
 return str(_lowerCAmelCase	) == str(_lowerCAmelCase	)[::-1]



def 						A_							(	_lowerCAmelCase	)		->					int:
 return int(_lowerCAmelCase	) + int(str(_lowerCAmelCase	)[::-1]	)



def 						A_							(	_lowerCAmelCase = 1_0000	)		->					int:
 UpperCamelCase      :   List[Any]			      =  []
 for num in range(1				,  _lowerCAmelCase	):
  UpperCamelCase      :   Union[str, Any]			      =  0
  UpperCamelCase      :   List[str]			      =  num
  while iterations < 50:
   UpperCamelCase      :   int			      =  sum_reverse(_lowerCAmelCase	)
   iterations += 1
   if is_palindrome(_lowerCAmelCase	):
    break
  else:
   lychrel_nums.append(_lowerCAmelCase	)
 return len(_lowerCAmelCase	)


if __name__ == "__main__":
    print(f"""{solution() = }""")
