





import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs

class 		__a				(    UpperCAmelCase      ):
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=None      ,   **_SCREAMING_SNAKE_CASE						)			->	str:




									"""simple docstring"""





									_UpperCAmelCase					=      parent
									_UpperCAmelCase					=      config_class
									_UpperCAmelCase					=      has_text_modality
									_UpperCAmelCase					=      kwargs
									_UpperCAmelCase					=      common_properties
		def      UpperCAmelCase__    (      self						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      self.config_class(**self.inputs_dict						)
									_UpperCAmelCase					=      (
									    ['hidden_size', 'num_attention_heads', 'num_hidden_layers']
									    if self.common_properties is None
									    else self.common_properties
									)

									# Add common fields for text models
									if self.has_text_modality:
																common_properties.extend(['vocab_size']						)

									# Test that config has the common properties as getters
									for prop in common_properties:
																self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)      ,   msg=f'''`{prop}` does not exist'''						)

									# Test that config has the common properties as setter
									for idx, name in enumerate(_SCREAMING_SNAKE_CASE						):
																try:
																							setattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)
																							self.parent.assertEqual(
																							    getattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)      ,   _SCREAMING_SNAKE_CASE      ,   msg=f'''`{name} value {idx} expected, but was {getattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)}'''						)
																except NotImplementedError:
																							# Some models might not be able to implement setters for common_properties
																							# In that case, a NotImplementedError is raised
																							pass

        # Test if config class can be called with Config(prop_name=..)
									for idx, name in enumerate(_SCREAMING_SNAKE_CASE						):
																try:
																							_UpperCAmelCase					=      self.config_class(**{name: idx}						)
																							self.parent.assertEqual(
																							    getattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)      ,   _SCREAMING_SNAKE_CASE      ,   msg=f'''`{name} value {idx} expected, but was {getattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)}'''						)
																except NotImplementedError:
																							# Some models might not be able to implement setters for common_properties
																							# In that case, a NotImplementedError is raised
																							pass
		def      UpperCAmelCase__    (      self						)			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.config_class(**self.inputs_dict						)
									_UpperCAmelCase					=      json.loads(config.to_json_string()						)
									for key, value in self.inputs_dict.items():
																self.parent.assertEqual(obj[key]      ,   _SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.config_class(**self.inputs_dict						)

									with tempfile.TemporaryDirectory() as tmpdirname:
																_UpperCAmelCase					=      os.path.join(_SCREAMING_SNAKE_CASE      ,   'config.json'						)
																config_first.to_json_file(_SCREAMING_SNAKE_CASE						)
																_UpperCAmelCase					=      self.config_class.from_json_file(_SCREAMING_SNAKE_CASE						)

									self.parent.assertEqual(config_second.to_dict()      ,   config_first.to_dict()						)
		def      UpperCAmelCase__    (      self						)			->	List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.config_class(**self.inputs_dict						)

									with tempfile.TemporaryDirectory() as tmpdirname:
																config_first.save_pretrained(_SCREAMING_SNAKE_CASE						)
																_UpperCAmelCase					=      self.config_class.from_pretrained(_SCREAMING_SNAKE_CASE						)

									self.parent.assertEqual(config_second.to_dict()      ,   config_first.to_dict()						)
		def      UpperCAmelCase__    (      self						)			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.config_class(**self.inputs_dict						)

									_UpperCAmelCase					=      'test'
									with tempfile.TemporaryDirectory() as tmpdirname:
																_UpperCAmelCase					=      os.path.join(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)
																config_first.save_pretrained(_SCREAMING_SNAKE_CASE						)
																_UpperCAmelCase					=      self.config_class.from_pretrained(_SCREAMING_SNAKE_CASE      ,   subfolder=_SCREAMING_SNAKE_CASE						)

									self.parent.assertEqual(config_second.to_dict()      ,   config_first.to_dict()						)
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									_UpperCAmelCase					=      self.config_class(**self.inputs_dict      ,   num_labels=5						)
									self.parent.assertEqual(len(config.idalabel						)      ,   5						)
									self.parent.assertEqual(len(config.labelaid						)      ,   5						)

									_UpperCAmelCase					=      3
									self.parent.assertEqual(len(config.idalabel						)      ,   3						)
									self.parent.assertEqual(len(config.labelaid						)      ,   3						)
		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





									if self.config_class.is_composition:
																return
									_UpperCAmelCase					=      self.config_class()
									self.parent.assertIsNotNone(_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      copy.deepcopy(_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      self.config_class(**_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      []
									for key, value in config_common_kwargs.items():
																if key == "torch_dtype":
																							if not is_torch_available():
																														continue
																							else:
																														import torch

																														if config.torch_dtype != torch.floataa:
																																					wrong_values.append(('torch_dtype', config.torch_dtype, torch.floataa)						)
																elif getattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						) != value:
																							wrong_values.append((key, getattr(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						), value)						)

									if len(_SCREAMING_SNAKE_CASE						) > 0:
																_UpperCAmelCase					=      '\n'.join([f'''- {v[0]}: got {v[1]} instead of {v[2]}''' for v in wrong_values]						)
																raise ValueError(f'''The following keys were not properly set in the config:\n{errors}'''						)






		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





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




from __future__ import annotations

import unittest

from transformers import BlenderbotConfig, BlenderbotTokenizer, is_tf_available
from transformers.testing_utils import require_tf, require_tokenizers, slow
from transformers.utils import cached_property

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


if is_tf_available():
		import tensorflow as tf

		from transformers import TFAutoModelForSeqaSeqLM, TFBlenderbotForConditionalGeneration, TFBlenderbotModel

@require_tf
class 		__a				:
		_a     :  Dict           =     BlenderbotConfig
		_a     :  Dict           =     {}
		_a     :  Union[str, Any]           =     'gelu'
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE=13      ,   _SCREAMING_SNAKE_CASE=7      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=False      ,   _SCREAMING_SNAKE_CASE=99      ,   _SCREAMING_SNAKE_CASE=32      ,   _SCREAMING_SNAKE_CASE=2      ,   _SCREAMING_SNAKE_CASE=4      ,   _SCREAMING_SNAKE_CASE=37      ,   _SCREAMING_SNAKE_CASE=0.1      ,   _SCREAMING_SNAKE_CASE=0.1      ,   _SCREAMING_SNAKE_CASE=20      ,   _SCREAMING_SNAKE_CASE=2      ,   _SCREAMING_SNAKE_CASE=1      ,   _SCREAMING_SNAKE_CASE=0      ,   )			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      parent
									_UpperCAmelCase					=      batch_size
									_UpperCAmelCase					=      seq_length
									_UpperCAmelCase					=      is_training
									_UpperCAmelCase					=      use_labels
									_UpperCAmelCase					=      vocab_size
									_UpperCAmelCase					=      hidden_size
									_UpperCAmelCase					=      num_hidden_layers
									_UpperCAmelCase					=      num_attention_heads
									_UpperCAmelCase					=      intermediate_size

									_UpperCAmelCase					=      hidden_dropout_prob
									_UpperCAmelCase					=      attention_probs_dropout_prob
									_UpperCAmelCase					=      max_position_embeddings
									_UpperCAmelCase					=      eos_token_id
									_UpperCAmelCase					=      pad_token_id
									_UpperCAmelCase					=      bos_token_id
		def      UpperCAmelCase__    (      self						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      ids_tensor([self.batch_size, self.seq_length - 1]      ,   self.vocab_size						)
									_UpperCAmelCase					=      tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size						)      ,   1						)
									_UpperCAmelCase					=      tf.concat([input_ids, eos_tensor]      ,   axis=1						)

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

									_UpperCAmelCase					=      self.config_cls(
									    vocab_size=self.vocab_size      ,   d_model=self.hidden_size      ,   encoder_layers=self.num_hidden_layers      ,   decoder_layers=self.num_hidden_layers      ,   encoder_attention_heads=self.num_attention_heads      ,   decoder_attention_heads=self.num_attention_heads      ,   encoder_ffn_dim=self.intermediate_size      ,   decoder_ffn_dim=self.intermediate_size      ,   dropout=self.hidden_dropout_prob      ,   attention_dropout=self.attention_probs_dropout_prob      ,   max_position_embeddings=self.max_position_embeddings      ,   eos_token_ids=[2]      ,   bos_token_id=self.bos_token_id      ,   pad_token_id=self.pad_token_id      ,   decoder_start_token_id=self.pad_token_id      ,   **self.config_updates      ,   )
									_UpperCAmelCase					=      prepare_blenderbot_inputs_dict(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)
									return config, inputs_dict






		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      TFBlenderbotModel(config=_SCREAMING_SNAKE_CASE						).get_decoder()
									_UpperCAmelCase					=      inputs_dict['input_ids']

									_UpperCAmelCase					=      input_ids[:1, :]
									_UpperCAmelCase					=      inputs_dict['attention_mask'][:1, :]
									_UpperCAmelCase					=      inputs_dict['head_mask']
									_UpperCAmelCase					=      1

									# first forward pass
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   head_mask=_SCREAMING_SNAKE_CASE      ,   use_cache=_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase		,	_UpperCAmelCase					=      outputs.to_tuple()

									# create hypothetical next token and extent to next_input_ids
									_UpperCAmelCase					=      ids_tensor((self.batch_size, 3)      ,   config.vocab_size						)
									_UpperCAmelCase					=      tf.cast(ids_tensor((self.batch_size, 3)      ,   2						)      ,   tf.inta						)

									# append to next input_ids and
									_UpperCAmelCase					=      tf.concat([input_ids, next_tokens]      ,   axis=-1						)
									_UpperCAmelCase					=      tf.concat([attention_mask, next_attn_mask]      ,   axis=-1						)

									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE						)[0]
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   past_key_values=_SCREAMING_SNAKE_CASE						)[0]

									self.parent.assertEqual(next_tokens.shape[1]      ,   output_from_past.shape[1]						)

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

									# test that outputs are equal for slice
									tf.debugging.assert_near(_SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   rtol=1e-3						)



def 	lowerCAmelCase__			(      a__:		Dict      ,  a__:		Dict      ,  a__:		Any      ,  a__:		Any=None      ,  a__:		List[Any]=None      ,  a__:		Union[str, Any]=None      ,  a__:		Tuple=None      ,  a__:		Union[str, Any]=None      ,  )  ->		Any:


							'''simple docstring'''





							if attention_mask is None:
														_UpperCAmelCase					=      tf.cast(tf.math.not_equal(a__      ,  config.pad_token_id	)      ,  tf.inta	)
							if decoder_attention_mask is None:
														_UpperCAmelCase					=      tf.concat(
														    [
														        tf.ones(decoder_input_ids[:, :1].shape      ,  dtype=tf.inta	),
														        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]      ,  config.pad_token_id	)      ,  tf.inta	),
														    ]      ,  axis=-1      ,  )
							if head_mask is None:
														_UpperCAmelCase					=      tf.ones((config.encoder_layers, config.encoder_attention_heads)	)
							if decoder_head_mask is None:
														_UpperCAmelCase					=      tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
							if cross_attn_head_mask is None:
														_UpperCAmelCase					=      tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
							return {
							    "input_ids": input_ids,
							    "decoder_input_ids": decoder_input_ids,
							    "attention_mask": attention_mask,
							    "decoder_attention_mask": decoder_attention_mask,
							    "head_mask": head_mask,
							    "decoder_head_mask": decoder_head_mask,
							    "cross_attn_head_mask": cross_attn_head_mask,
							}

@require_tf
class 		__a				(    UpperCAmelCase   ,				UpperCAmelCase   ,				unittest.TestCase      ):
		_a     :  List[Any]           =     (TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
		_a     :  List[str]           =     (TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
		_a     :  List[str]           =     (
		    {
		        'conversational': TFBlenderbotForConditionalGeneration,
		        'feature-extraction': TFBlenderbotModel,
		        'summarization': TFBlenderbotForConditionalGeneration,
		        'text2text-generation': TFBlenderbotForConditionalGeneration,
		        'translation': TFBlenderbotForConditionalGeneration,
		    }
		    if is_tf_available()
		    else {}
		)
		_a     :  Dict           =     True
		_a     :  int           =     False
		_a     :  Union[str, Any]           =     False
		def      UpperCAmelCase__    (      self						)			->	List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      TFBlenderbotModelTester(self						)
									_UpperCAmelCase					=      ConfigTester(self      ,   config_class=_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	str:




									"""simple docstring"""





									self.config_tester.run_common_tests()






		def      UpperCAmelCase__    (      self						)			->	List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.check_decoder_model_past_large_inputs(*_SCREAMING_SNAKE_CASE						)



@require_tokenizers
@require_tf
class 		__a				(    unittest.TestCase      ):
		_a     :  int           =     ['My friends are cool but they eat too many carbs.']
		_a     :  List[Any]           =     'facebook/blenderbot-400M-distill'
		@cached_property
		def      UpperCAmelCase__    (      self						)			->	List[Any]:




									"""simple docstring"""





									return BlenderbotTokenizer.from_pretrained(self.model_name						)
		@cached_property
		def      UpperCAmelCase__    (      self						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name						)
									return model






		@slow
		def      UpperCAmelCase__    (      self						)			->	str:




									"""simple docstring"""





									_UpperCAmelCase					=      self.tokenizer(self.src_text      ,   return_tensors='tf'						)
									_UpperCAmelCase					=      self.model.generate(
									    model_inputs.input_ids      ,   )
									_UpperCAmelCase					=      self.tokenizer.batch_decode(generated_ids.numpy()      ,   skip_special_tokens=_SCREAMING_SNAKE_CASE						)[0]
									assert (
									    generated_words
									    == " That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?"
									)
