
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   UpperCAmelCase		:



   def __init__(self		:					Tuple    ,						snake_case__		:					int    ,						snake_case__		:					Optional[int]=13    ,						snake_case__		:					List[Any]=7    ,						snake_case__		:					Tuple=True    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					Union[str, Any]=99    ,						snake_case__		:					Any=32    ,						snake_case__		:					Optional[Any]=5    ,						snake_case__		:					Any=4    ,						snake_case__		:					str=37    ,						snake_case__		:					Optional[int]="gelu"    ,						snake_case__		:					List[Any]=0.1    ,						snake_case__		:					List[str]=0.1    ,						snake_case__		:					int=50    ,						snake_case__		:					List[Any]=0.02    ,						snake_case__		:					Any=True    ,						snake_case__		:					List[Any]=None    ,						)		->	Tuple:


          '''simple docstring'''


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



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	List[Any]:


          '''simple docstring'''


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

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

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

          snake_case       :   Optional[Any]							=      self.get_config()

          return config, input_ids, input_mask, token_labels



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	int:


          '''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=snake_case__    ,						initializer_range=self.initializer_range    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	Dict:


          '''simple docstring'''


          (
              (
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					
          )       :   Tuple							=      self.prepare_config_and_inputs()

          snake_case       :   Any							=      True
          snake_case       :   List[str]							=      floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
          snake_case       :   Optional[int]							=      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 				_SCREAMING_SNAKE_CASE   (self		:					List[Any]    ,						snake_case__		:					str    ,						snake_case__		:					str    ,						snake_case__		:					Tuple    ,						snake_case__		:					int    ,						**snake_case__		:					int    ,						)		->	str:


          '''simple docstring'''


          snake_case       :   int							=      BertGenerationEncoder(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   str							=      model(snake_case__    ,						attention_mask=snake_case__ )
          snake_case       :   List[Any]							=      model(snake_case__ )
          self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, self.seq_length, self.hidden_size) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int    ,						snake_case__		:					Tuple    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					Optional[int]    ,						snake_case__		:					str    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					int    ,						**snake_case__		:					Optional[Any]    ,						)		->	Optional[Any]:


          '''simple docstring'''


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



   def 				_SCREAMING_SNAKE_CASE   (self		:					int    ,						snake_case__		:					Optional[Any]    ,						snake_case__		:					Any    ,						snake_case__		:					Dict    ,						snake_case__		:					Any    ,						snake_case__		:					Union[str, Any]    ,						snake_case__		:					str    ,						**snake_case__		:					str    ,						)		->	Dict:


          '''simple docstring'''


          snake_case       :   Optional[int]							=      True
          snake_case       :   Union[str, Any]							=      True
          snake_case       :   Optional[int]							=      BertGenerationDecoder(config=snake_case__ ).to(snake_case__ ).eval()

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

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

          # append to next input_ids and
          snake_case       :   List[Any]							=      torch.cat([input_ids, next_tokens]    ,						dim=-1 )
          snake_case       :   Optional[Any]							=      torch.cat([input_mask, next_mask]    ,						dim=-1 )

          snake_case       :   Tuple							=      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]
          snake_case       :   Dict							=      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
          snake_case       :   Tuple							=      ids_tensor((1,)    ,						output_from_past.shape[-1] ).item()
          snake_case       :   Optional[Any]							=      output_from_no_past[:, -3:, random_slice_idx].detach()
          snake_case       :   Optional[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(snake_case__    ,						snake_case__    ,						atol=1e-3 ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple    ,						snake_case__		:					Tuple    ,						snake_case__		:					Dict    ,						snake_case__		:					Tuple    ,						snake_case__		:					Optional[Any]    ,						*snake_case__		:					List[Any]    ,						)		->	str:


          '''simple docstring'''


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



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Optional[int]:


          '''simple docstring'''


          snake_case				,					snake_case				,					snake_case				,					snake_case       :   List[Any]							=      self.prepare_config_and_inputs()
          snake_case       :   Dict							=      {"input_ids": input_ids, "attention_mask": input_mask}
          return config, inputs_dict






@require_torch
class   UpperCAmelCase		(						A_       ,A_       ,A_       ,unittest.TestCase ):
   A__					:		str						     =     (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
   A__					:		Any						     =     (BertGenerationDecoder,) if is_torch_available() else ()
   A__					:		str						     =     (
       {"feature-extraction": BertGenerationEncoder, "text-generation": BertGenerationDecoder}
       if is_torch_available()
       else {}
   )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Any:


          '''simple docstring'''


          snake_case       :   Dict							=      BertGenerationEncoderTester(self )
          snake_case       :   List[Any]							=      ConfigTester(self    ,						config_class=snake_case__    ,						hidden_size=37 )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	List[Any]:


          '''simple docstring'''


          self.config_tester.run_common_tests()



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Any:


          '''simple docstring'''


          snake_case       :   Tuple							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	int:


          '''simple docstring'''


          snake_case				,					snake_case				,					snake_case				,					snake_case       :   Union[str, Any]							=      self.model_tester.prepare_config_and_inputs()
          snake_case       :   List[Any]							=      "bert"
          self.model_tester.create_and_check_model(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Union[str, Any] )		->	int:


          '''simple docstring'''


          snake_case       :   List[str]							=      self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_model_as_decoder(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Any )		->	Dict:


          '''simple docstring'''


          snake_case       :   Tuple							=      self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_decoder_model_past_large_inputs(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Any:


          '''simple docstring'''


          (
              (
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					(
              snake_case
          )				,					
          )       :   Union[str, Any]							=      self.model_tester.prepare_config_and_inputs_for_decoder()

          snake_case       :   Dict							=      None

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



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	int:


          '''simple docstring'''


          snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_for_causal_lm(*snake_case__ )



   @slow
   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Tuple:


          '''simple docstring'''


          snake_case       :   Optional[int]							=      BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder" )
          self.assertIsNotNone(snake_case__ )






@require_torch
class   UpperCAmelCase		(						unittest.TestCase ):



   @slow
   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	Any:


          '''simple docstring'''


          snake_case       :   Tuple							=      BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder" )
          snake_case       :   Dict							=      torch.tensor([[1_01, 75_92, 10_10, 20_26, 38_99, 20_03, 1_01_40, 1_02]] )
          with torch.no_grad():
                 snake_case       :   List[str]							=      model(snake_case__ )[0]
          snake_case       :   List[str]							=      torch.Size([1, 8, 10_24] )
          self.assertEqual(output.shape    ,						snake_case__ )
          snake_case       :   int							=      torch.tensor(
              [[[0.1775, 0.0083, -0.0321], [1.6002, 0.1287, 0.3912], [2.1473, 0.5791, 0.6066]]] )
          self.assertTrue(torch.allclose(output[:, :3, :3]    ,						snake_case__    ,						atol=1e-4 ) )






@require_torch
class   UpperCAmelCase		(						unittest.TestCase ):



   @slow
   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Tuple:


          '''simple docstring'''


          snake_case       :   List[Any]							=      BertGenerationDecoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder" )
          snake_case       :   List[str]							=      torch.tensor([[1_01, 75_92, 10_10, 20_26, 38_99, 20_03, 1_01_40, 1_02]] )
          with torch.no_grad():
                 snake_case       :   List[Any]							=      model(snake_case__ )[0]
          snake_case       :   List[Any]							=      torch.Size([1, 8, 5_03_58] )
          self.assertEqual(output.shape    ,						snake_case__ )
          snake_case       :   Union[str, Any]							=      torch.tensor(
              [[[-0.5788, -2.5994, -3.7054], [0.0438, 4.7997, 1.8795], [1.5862, 6.6409, 4.4638]]] )
          self.assertTrue(torch.allclose(output[:, :3, :3]    ,						snake_case__    ,						atol=1e-4 ) )









"""simple docstring"""







__lowercase    					=      {
    """Pillow""": """Pillow<10.0.0""",
    """accelerate""": """accelerate>=0.20.3""",
    """av""": """av==9.2.0""",
    """beautifulsoup4""": """beautifulsoup4""",
    """black""": """black~=23.1""",
    """codecarbon""": """codecarbon==1.2.0""",
    """cookiecutter""": """cookiecutter==1.7.3""",
    """dataclasses""": """dataclasses""",
    """datasets""": """datasets!=2.5.0""",
    """decord""": """decord==0.6.0""",
    """deepspeed""": """deepspeed>=0.9.3""",
    """diffusers""": """diffusers""",
    """dill""": """dill<0.3.5""",
    """evaluate""": """evaluate>=0.2.0""",
    """fairscale""": """fairscale>0.3""",
    """faiss-cpu""": """faiss-cpu""",
    """fastapi""": """fastapi""",
    """filelock""": """filelock""",
    """flax""": """flax>=0.4.1,<=0.7.0""",
    """ftfy""": """ftfy""",
    """fugashi""": """fugashi>=1.0""",
    """GitPython""": """GitPython<3.1.19""",
    """hf-doc-builder""": """hf-doc-builder>=0.3.0""",
    """huggingface-hub""": """huggingface-hub>=0.14.1,<1.0""",
    """importlib_metadata""": """importlib_metadata""",
    """ipadic""": """ipadic>=1.0.0,<2.0""",
    """isort""": """isort>=5.5.4""",
    """jax""": """jax>=0.2.8,!=0.3.2,<=0.4.13""",
    """jaxlib""": """jaxlib>=0.1.65,<=0.4.13""",
    """jieba""": """jieba""",
    """kenlm""": """kenlm""",
    """keras-nlp""": """keras-nlp>=0.3.1""",
    """librosa""": """librosa""",
    """nltk""": """nltk""",
    """natten""": """natten>=0.14.6""",
    """numpy""": """numpy>=1.17""",
    """onnxconverter-common""": """onnxconverter-common""",
    """onnxruntime-tools""": """onnxruntime-tools>=1.4.2""",
    """onnxruntime""": """onnxruntime>=1.4.0""",
    """opencv-python""": """opencv-python""",
    """optuna""": """optuna""",
    """optax""": """optax>=0.0.8,<=0.1.4""",
    """packaging""": """packaging>=20.0""",
    """parameterized""": """parameterized""",
    """phonemizer""": """phonemizer""",
    """protobuf""": """protobuf""",
    """psutil""": """psutil""",
    """pyyaml""": """pyyaml>=5.1""",
    """pydantic""": """pydantic<2""",
    """pytest""": """pytest>=7.2.0""",
    """pytest-timeout""": """pytest-timeout""",
    """pytest-xdist""": """pytest-xdist""",
    """python""": """python>=3.8.0""",
    """ray[tune]""": """ray[tune]""",
    """regex""": """regex!=2019.12.17""",
    """requests""": """requests""",
    """rhoknp""": """rhoknp>=1.1.0,<1.3.1""",
    """rjieba""": """rjieba""",
    """rouge-score""": """rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1""",
    """ruff""": """ruff>=0.0.241,<=0.0.259""",
    """sacrebleu""": """sacrebleu>=1.4.12,<2.0.0""",
    """sacremoses""": """sacremoses""",
    """safetensors""": """safetensors>=0.3.1""",
    """sagemaker""": """sagemaker>=2.31.0""",
    """scikit-learn""": """scikit-learn""",
    """sentencepiece""": """sentencepiece>=0.1.91,!=0.1.92""",
    """sigopt""": """sigopt""",
    """starlette""": """starlette""",
    """sudachipy""": """sudachipy>=0.6.6""",
    """sudachidict_core""": """sudachidict_core>=20220729""",
    """tensorflow-cpu""": """tensorflow-cpu>=2.6,<2.14""",
    """tensorflow""": """tensorflow>=2.6,<2.14""",
    """tensorflow-text""": """tensorflow-text<2.14""",
    """tf2onnx""": """tf2onnx""",
    """timeout-decorator""": """timeout-decorator""",
    """timm""": """timm""",
    """tokenizers""": """tokenizers>=0.11.1,!=0.11.3,<0.14""",
    """torch""": """torch>=1.9,!=1.12.0""",
    """torchaudio""": """torchaudio""",
    """torchvision""": """torchvision""",
    """pyctcdecode""": """pyctcdecode>=0.4.0""",
    """tqdm""": """tqdm>=4.27""",
    """unidic""": """unidic>=1.0.2""",
    """unidic_lite""": """unidic_lite>=1.0.7""",
    """urllib3""": """urllib3<2.0.0""",
    """uvicorn""": """uvicorn""",
}






