




'''simple docstring'''



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


   """simple docstring"""

   lowerCamelCase_      =						BlenderbotConfig
   lowerCamelCase_      =						{}
   lowerCamelCase_      =						'''gelu'''



   def __init__(   self :     Any  ,				__lowerCamelCase :     Optional[Any]  ,				__lowerCamelCase :     Union[str, Any]=1_3  ,				__lowerCamelCase :     Tuple=7  ,				__lowerCamelCase :     str=True  ,				__lowerCamelCase :     Any=False  ,				__lowerCamelCase :     Dict=9_9  ,				__lowerCamelCase :     Optional[Any]=3_2  ,				__lowerCamelCase :     List[Any]=2  ,				__lowerCamelCase :     Union[str, Any]=4  ,				__lowerCamelCase :     List[Any]=3_7  ,				__lowerCamelCase :     Union[str, Any]=0.1  ,				__lowerCamelCase :     int=0.1  ,				__lowerCamelCase :     List[str]=2_0  ,				__lowerCamelCase :     Union[str, Any]=2  ,				__lowerCamelCase :     List[Any]=1  ,				__lowerCamelCase :     Tuple=0  ,				):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				parent
      _SCREAMING_SNAKE_CASE	=				batch_size
      _SCREAMING_SNAKE_CASE	=				seq_length
      _SCREAMING_SNAKE_CASE	=				is_training
      _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_dropout_prob
      _SCREAMING_SNAKE_CASE	=				attention_probs_dropout_prob
      _SCREAMING_SNAKE_CASE	=				max_position_embeddings
      _SCREAMING_SNAKE_CASE	=				eos_token_id
      _SCREAMING_SNAKE_CASE	=				pad_token_id
      _SCREAMING_SNAKE_CASE	=				bos_token_id



   def 							lowerCAmelCase_      (   self :     List[Any]   ):

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

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

      _SCREAMING_SNAKE_CASE	=				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  ,				)
      _SCREAMING_SNAKE_CASE	=				prepare_blenderbot_inputs_dict(__lowerCamelCase  ,				__lowerCamelCase  ,				__lowerCamelCase   )
      return config, inputs_dict



   def 							lowerCAmelCase_      (   self :     Optional[Any]  ,				__lowerCamelCase :     Any  ,				__lowerCamelCase :     Tuple   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				TFBlenderbotModel(config=__lowerCamelCase   ).get_decoder()
      _SCREAMING_SNAKE_CASE	=				inputs_dict["input_ids"]

      _SCREAMING_SNAKE_CASE	=				input_ids[:1, :]
      _SCREAMING_SNAKE_CASE	=				inputs_dict["attention_mask"][:1, :]
      _SCREAMING_SNAKE_CASE	=				inputs_dict["head_mask"]
      _SCREAMING_SNAKE_CASE	=				1

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

      _SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE	=				outputs.to_tuple()

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

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

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

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

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

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


def 			SCREAMING_SNAKE_CASE_			(							__A    :			int	,					__A    :			str	,					__A    :			Dict	,					__A    :			str=None	,					__A    :			Optional[Any]=None	,					__A    :			Optional[int]=None	,					__A    :			List[str]=None	,					__A    :			Any=None	,					)			->			int:
   if attention_mask is None:
      _SCREAMING_SNAKE_CASE	=				tf.cast(tf.math.not_equal(__A	,					config.pad_token_id  )	,					tf.inta  )
   if decoder_attention_mask is None:
      _SCREAMING_SNAKE_CASE	=				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:
      _SCREAMING_SNAKE_CASE	=				tf.ones((config.encoder_layers, config.encoder_attention_heads)  )
   if decoder_head_mask is None:
      _SCREAMING_SNAKE_CASE	=				tf.ones((config.decoder_layers, config.decoder_attention_heads)  )
   if cross_attn_head_mask is None:
      _SCREAMING_SNAKE_CASE	=				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 		lowercase_   (			A					,  A					,  unittest.TestCase       ):


   """simple docstring"""

   lowerCamelCase_      =						(TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
   lowerCamelCase_      =						(TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
   lowerCamelCase_      =						(
       {
           '''conversational''': TFBlenderbotForConditionalGeneration,
           '''feature-extraction''': TFBlenderbotModel,
           '''summarization''': TFBlenderbotForConditionalGeneration,
           '''text2text-generation''': TFBlenderbotForConditionalGeneration,
           '''translation''': TFBlenderbotForConditionalGeneration,
       }
       if is_tf_available()
       else {}
   )
   lowerCamelCase_      =						True
   lowerCamelCase_      =						False
   lowerCamelCase_      =						False



   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				TFBlenderbotModelTester(self   )
      _SCREAMING_SNAKE_CASE	=				ConfigTester(self  ,				config_class=__lowerCamelCase   )



   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      self.config_tester.run_common_tests()



   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase   )







@require_tokenizers
@require_tf
class 		lowercase_   (			unittest.TestCase       ):


   """simple docstring"""

   lowerCamelCase_      =						['''My friends are cool but they eat too many carbs.''']
   lowerCamelCase_      =						'''facebook/blenderbot-400M-distill'''



   @cached_property
   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      return BlenderbotTokenizer.from_pretrained(self.model_name   )



   @cached_property
   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name   )
      return model



   @slow
   def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

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







'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowerCamelCase_			=						{
    'configuration_ctrl': ['CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CTRLConfig'],
    'tokenization_ctrl': ['CTRLTokenizer'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase_			=						[
     'CTRL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'CTRLForSequenceClassification',
     'CTRLLMHeadModel',
     'CTRLModel',
     'CTRLPreTrainedModel',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCamelCase_			=						[
     'TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFCTRLForSequenceClassification',
     'TFCTRLLMHeadModel',
     'TFCTRLModel',
     'TFCTRLPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig
 from .tokenization_ctrl import CTRLTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_ctrl import (
      CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
      CTRLForSequenceClassification,
      CTRLLMHeadModel,
      CTRLModel,
      CTRLPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_ctrl import (
      TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFCTRLForSequenceClassification,
      TFCTRLLMHeadModel,
      TFCTRLModel,
      TFCTRLPreTrainedModel,
  )

else:
 import sys

 lowerCamelCase_			=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

