





from __future__ import annotations

import unittest

from transformers import BlenderbotSmallConfig, BlenderbotSmallTokenizer, 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, TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel



@require_tf
class   _SCREAMING_SNAKE_CASE		:







 '''simple docstring'''
 lowercase_						=     BlenderbotSmallConfig
 lowercase_						=     {}
 lowercase_						=     "gelu"

 def __init__(self							:  str			,					UpperCAmelCase_							:  Dict			,					UpperCAmelCase_							:  Tuple=13			,					UpperCAmelCase_							:  str=7			,					UpperCAmelCase_							:  Tuple=True			,					UpperCAmelCase_							:  Union[str, Any]=False			,					UpperCAmelCase_							:  Optional[int]=99			,					UpperCAmelCase_							:  Optional[int]=32			,					UpperCAmelCase_							:  Any=2			,					UpperCAmelCase_							:  Dict=4			,					UpperCAmelCase_							:  Optional[int]=37			,					UpperCAmelCase_							:  str=0.1			,					UpperCAmelCase_							:  Optional[Any]=0.1			,					UpperCAmelCase_							:  List[str]=20			,					UpperCAmelCase_							:  Any=2			,					UpperCAmelCase_							:  Dict=1			,					UpperCAmelCase_							:  Tuple=0			,					)			->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__: List[str]         =parent
   lowerCamelCase__: Optional[int]         =batch_size
   lowerCamelCase__: Tuple         =seq_length
   lowerCamelCase__: Tuple         =is_training
   lowerCamelCase__: Union[str, Any]         =use_labels
   lowerCamelCase__: Optional[Any]         =vocab_size
   lowerCamelCase__: Optional[int]         =hidden_size
   lowerCamelCase__: int         =num_hidden_layers
   lowerCamelCase__: Union[str, Any]         =num_attention_heads
   lowerCamelCase__: Tuple         =intermediate_size

   lowerCamelCase__: Optional[Any]         =hidden_dropout_prob
   lowerCamelCase__: int         =attention_probs_dropout_prob
   lowerCamelCase__: List[Any]         =max_position_embeddings
   lowerCamelCase__: Tuple         =eos_token_id
   lowerCamelCase__: Tuple         =pad_token_id
   lowerCamelCase__: Optional[int]         =bos_token_id

 def 				SCREAMING_SNAKE_CASE_   (self							:  Any)			->int:



   '''simple docstring'''



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

   lowerCamelCase__: str         =ids_tensor([self.batch_size, self.seq_length]			,					self.vocab_size)

   lowerCamelCase__: List[Any]         =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			,					)
   lowerCamelCase__: Optional[Any]         =prepare_blenderbot_small_inputs_dict(UpperCAmelCase_			,					UpperCAmelCase_			,					UpperCAmelCase_)
   return config, inputs_dict







 def 				SCREAMING_SNAKE_CASE_   (self							:  Any			,					UpperCAmelCase_							:  Union[str, Any]			,					UpperCAmelCase_							:  str)			->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__: Any         =TFBlenderbotSmallModel(config=UpperCAmelCase_).get_decoder()
   lowerCamelCase__: str         =inputs_dict["input_ids"]

   lowerCamelCase__: Optional[int]         =input_ids[:1, :]
   lowerCamelCase__: List[str]         =inputs_dict["attention_mask"][:1, :]
   lowerCamelCase__: List[str]         =inputs_dict["head_mask"]
   lowerCamelCase__: Tuple         =1

   # first forward pass
   lowerCamelCase__: Union[str, Any]         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					head_mask=UpperCAmelCase_			,					use_cache=UpperCAmelCase_)

   lowerCamelCase__    ,   lowerCamelCase__: int         =outputs.to_tuple()

   # create hypothetical next token and extent to next_input_ids
   lowerCamelCase__: Dict         =ids_tensor((self.batch_size, 3)			,					config.vocab_size)
   lowerCamelCase__: Optional[int]         =tf.cast(ids_tensor((self.batch_size, 3)			,					2)			,					tf.inta)

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

   lowerCamelCase__: List[str]         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_)[0]
   lowerCamelCase__: Optional[Any]         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					past_key_values=UpperCAmelCase_)[0]

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

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

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





def 	lowerCAmelCase_					(			__a      ,       __a      ,       __a      ,       __a=None      ,       __a=None      ,       __a=None      ,       __a=None      ,       __a=None      ,       )	->						List[str]:







  """simple docstring"""





  if attention_mask is None:
    lowerCamelCase__: List[str]         =tf.cast(tf.math.not_equal(__a      ,       config.pad_token_id						)      ,       tf.inta						)
  if decoder_attention_mask is None:
    lowerCamelCase__: Any         =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:
    lowerCamelCase__: str         =tf.ones((config.encoder_layers, config.encoder_attention_heads)						)
  if decoder_head_mask is None:
    lowerCamelCase__: List[Any]         =tf.ones((config.decoder_layers, config.decoder_attention_heads)						)
  if cross_attn_head_mask is None:
    lowerCamelCase__: List[str]         =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   _SCREAMING_SNAKE_CASE		(      __SCREAMING_SNAKE_CASE       ,				__SCREAMING_SNAKE_CASE       ,				unittest.TestCase       ):







 '''simple docstring'''
 lowercase_						=     (
     (TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
 )
 lowercase_						=     (TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
 lowercase_						=     (
     {
         "conversational": TFBlenderbotSmallForConditionalGeneration,
         "feature-extraction": TFBlenderbotSmallModel,
         "summarization": TFBlenderbotSmallForConditionalGeneration,
         "text2text-generation": TFBlenderbotSmallForConditionalGeneration,
         "translation": TFBlenderbotSmallForConditionalGeneration,
     }
     if is_tf_available()
     else {}
 )
 lowercase_						=     True
 lowercase_						=     False
 lowercase_						=     False

 def 				SCREAMING_SNAKE_CASE_   (self							:  List[str])			->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__: Union[str, Any]         =TFBlenderbotSmallModelTester(self)
   lowerCamelCase__: Optional[int]         =ConfigTester(self			,					config_class=UpperCAmelCase_)

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



   '''simple docstring'''



   self.config_tester.run_common_tests()







 def 				SCREAMING_SNAKE_CASE_   (self							:  List[Any])			->Any:



   '''simple docstring'''



   lowerCamelCase__: str         =self.model_tester.prepare_config_and_inputs_for_common()
   self.model_tester.check_decoder_model_past_large_inputs(*UpperCAmelCase_)



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







 '''simple docstring'''
 lowercase_						=     [
     "Social anxiety\nWow, I am never shy. Do you have anxiety?\nYes. I end up sweating and blushing and feel like "
     "  i'm going to throw up.\nand why is that?"
 ]
 lowercase_						=     "facebook/blenderbot_small-90M"

 @cached_property
 def 				SCREAMING_SNAKE_CASE_   (self							:  Union[str, Any])			->Tuple:



   '''simple docstring'''



   return BlenderbotSmallTokenizer.from_pretrained("facebook/blenderbot-90M")

 @cached_property
 def 				SCREAMING_SNAKE_CASE_   (self							:  Any)			->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__: Optional[Any]         =TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name)
   return model







 @slow
 def 				SCREAMING_SNAKE_CASE_   (self							:  Dict)			->List[str]:



   '''simple docstring'''



   lowerCamelCase__: Dict         =self.tokenizer(self.src_text			,					return_tensors="tf")
   lowerCamelCase__: Optional[int]         =self.model.generate(
       model_inputs.input_ids			,					attention_mask=model_inputs.attention_mask			,					num_beams=2			,					use_cache=UpperCAmelCase_			,					)
   lowerCamelCase__: Any         =self.tokenizer.batch_decode(generated_ids.numpy()			,					skip_special_tokens=UpperCAmelCase_)[0]
   assert generated_words in (
       "i don't know. i just feel like i'm going to throw up. it's not fun.",
       "i'm not sure. i just feel like i've been feeling like i have to be in a certain place",
       "i'm not sure. i just feel like i've been in a bad situation.",
   )





'''simple docstring'''
from typing import TYPE_CHECKING

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


UpperCAmelCase_			:  Optional[Any]										=   {
    'configuration_transfo_xl': ['TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TransfoXLConfig'],
    'tokenization_transfo_xl': ['TransfoXLCorpus', 'TransfoXLTokenizer'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Any										=   [
     'TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'AdaptiveEmbedding',
     'TransfoXLForSequenceClassification',
     'TransfoXLLMHeadModel',
     'TransfoXLModel',
     'TransfoXLPreTrainedModel',
     'load_tf_weights_in_transfo_xl',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Optional[Any]										=   [
     'TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFAdaptiveEmbedding',
     'TFTransfoXLForSequenceClassification',
     'TFTransfoXLLMHeadModel',
     'TFTransfoXLMainLayer',
     'TFTransfoXLModel',
     'TFTransfoXLPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
 from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_transfo_xl import (
      TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      AdaptiveEmbedding,
      TransfoXLForSequenceClassification,
      TransfoXLLMHeadModel,
      TransfoXLModel,
      TransfoXLPreTrainedModel,
      load_tf_weights_in_transfo_xl,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_transfo_xl import (
      TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFAdaptiveEmbedding,
      TFTransfoXLForSequenceClassification,
      TFTransfoXLLMHeadModel,
      TFTransfoXLMainLayer,
      TFTransfoXLModel,
      TFTransfoXLPreTrainedModel,
  )

else:
 import sys

 UpperCAmelCase_			:  Optional[int]										=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






