





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   __lowerCAmelCase			:
   _UpperCamelCase :						Tuple     		=				BlenderbotConfig
   _UpperCamelCase :						Optional[Any]     		=				{}
   _UpperCamelCase :						List[Any]     		=				"""gelu"""





   def __init__( self					,			snake_case					,			snake_case=13					,			snake_case=7					,			snake_case=True					,			snake_case=False					,			snake_case=99					,			snake_case=32					,			snake_case=2					,			snake_case=4					,			snake_case=37					,			snake_case=0.1					,			snake_case=0.1					,			snake_case=20					,			snake_case=2					,			snake_case=1					,			snake_case=0					,			)				->  Optional[int]:
      """simple docstring"""





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

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





   def 	_snake_case ( self      )				->  str:
      """simple docstring"""





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

      a__	:						int      		=  ids_tensor([self.batch_size, self.seq_length]					,			self.vocab_size      )

      a__	:						Dict      		=  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					,			)
      a__	:						Union[str, Any]      		=  prepare_blenderbot_inputs_dict(snake_case					,			snake_case					,			snake_case      )
      return config, inputs_dict





   def 	_snake_case ( self					,			snake_case					,			snake_case      )				->  Dict:
      """simple docstring"""





      a__	:						Optional[int]      		=  TFBlenderbotModel(config=snake_case      ).get_decoder()
      a__	:						Optional[int]      		=  inputs_dict["input_ids"]

      a__	:						Tuple      		=  input_ids[:1, :]
      a__	:						str      		=  inputs_dict["attention_mask"][:1, :]
      a__	:						Optional[int]      		=  inputs_dict["head_mask"]
      a__	:						Any      		=  1

      # first forward pass
      a__	:						str      		=  model(snake_case					,			attention_mask=snake_case					,			head_mask=snake_case					,			use_cache=snake_case      )

      a__		,     a__	:						Any      		=  outputs.to_tuple()

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

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

      a__	:						int      		=  model(snake_case					,			attention_mask=snake_case      )[0]
      a__	:						Tuple      		=  model(snake_case					,			attention_mask=snake_case					,			past_key_values=snake_case      )[0]

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

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

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







def       _A  (      lowerCamelCase							, lowerCamelCase							, lowerCamelCase							, lowerCamelCase=None							, lowerCamelCase=None							, lowerCamelCase=None							, lowerCamelCase=None							, lowerCamelCase=None							, ):
   if attention_mask is None:
      a__	:						List[Any]      		=  tf.cast(tf.math.not_equal(lowerCamelCase							, config.pad_token_id   )							, tf.inta   )
   if decoder_attention_mask is None:
      a__	:						Union[str, 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:
      a__	:						Union[str, Any]      		=  tf.ones((config.encoder_layers, config.encoder_attention_heads)   )
   if decoder_head_mask is None:
      a__	:						Dict      		=  tf.ones((config.decoder_layers, config.decoder_attention_heads)   )
   if cross_attn_head_mask is None:
      a__	:						List[Any]      		=  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   __lowerCAmelCase			(					_UpperCamelCase		,_UpperCamelCase		,unittest.TestCase  ):
   _UpperCamelCase :						str     		=				(TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
   _UpperCamelCase :						str     		=				(TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
   _UpperCamelCase :						Dict     		=				(
       {
           """conversational""": TFBlenderbotForConditionalGeneration,
           """feature-extraction""": TFBlenderbotModel,
           """summarization""": TFBlenderbotForConditionalGeneration,
           """text2text-generation""": TFBlenderbotForConditionalGeneration,
           """translation""": TFBlenderbotForConditionalGeneration,
       }
       if is_tf_available()
       else {}
   )
   _UpperCamelCase :						Any     		=				True
   _UpperCamelCase :						Union[str, Any]     		=				False
   _UpperCamelCase :						Dict     		=				False





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





      a__	:						str      		=  TFBlenderbotModelTester(self      )
      a__	:						Optional[int]      		=  ConfigTester(self					,			config_class=snake_case      )





   def 	_snake_case ( self      )				->  Tuple:
      """simple docstring"""





      self.config_tester.run_common_tests()





   def 	_snake_case ( self      )				->  int:
      """simple docstring"""





      a__	:						Any      		=  self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_decoder_model_past_large_inputs(*snake_case      )







@require_tokenizers
@require_tf
class   __lowerCAmelCase			(					unittest.TestCase  ):
   _UpperCamelCase :						Dict     		=				["""My friends are cool but they eat too many carbs."""]
   _UpperCamelCase :						List[Any]     		=				"""facebook/blenderbot-400M-distill"""





   @cached_property
   def 	_snake_case ( self      )				->  List[Any]:
      """simple docstring"""





      return BlenderbotTokenizer.from_pretrained(self.model_name      )





   @cached_property
   def 	_snake_case ( self      )				->  Tuple:
      """simple docstring"""





      a__	:						int      		=  TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name      )
      return model





   @slow
   def 	_snake_case ( self      )				->  Optional[Any]:
      """simple docstring"""





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








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE__       :			str			      =						{
    """configuration_distilbert""": [
        """DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """DistilBertConfig""",
        """DistilBertOnnxConfig""",
    ],
    """tokenization_distilbert""": ["""DistilBertTokenizer"""],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			Optional[int]			      =						["""DistilBertTokenizerFast"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			Tuple			      =						[
      """DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """DistilBertForMaskedLM""",
      """DistilBertForMultipleChoice""",
      """DistilBertForQuestionAnswering""",
      """DistilBertForSequenceClassification""",
      """DistilBertForTokenClassification""",
      """DistilBertModel""",
      """DistilBertPreTrainedModel""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			List[Any]			      =						[
      """TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFDistilBertForMaskedLM""",
      """TFDistilBertForMultipleChoice""",
      """TFDistilBertForQuestionAnswering""",
      """TFDistilBertForSequenceClassification""",
      """TFDistilBertForTokenClassification""",
      """TFDistilBertMainLayer""",
      """TFDistilBertModel""",
      """TFDistilBertPreTrainedModel""",
  ]

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			Any			      =						[
      """FlaxDistilBertForMaskedLM""",
      """FlaxDistilBertForMultipleChoice""",
      """FlaxDistilBertForQuestionAnswering""",
      """FlaxDistilBertForSequenceClassification""",
      """FlaxDistilBertForTokenClassification""",
      """FlaxDistilBertModel""",
      """FlaxDistilBertPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_distilbert import (
      DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
      DistilBertConfig,
      DistilBertOnnxConfig,
  )
  from .tokenization_distilbert import DistilBertTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_distilbert_fast import DistilBertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_distilbert import (
        DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DistilBertForMaskedLM,
        DistilBertForMultipleChoice,
        DistilBertForQuestionAnswering,
        DistilBertForSequenceClassification,
        DistilBertForTokenClassification,
        DistilBertModel,
        DistilBertPreTrainedModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_distilbert import (
        TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFDistilBertForMaskedLM,
        TFDistilBertForMultipleChoice,
        TFDistilBertForQuestionAnswering,
        TFDistilBertForSequenceClassification,
        TFDistilBertForTokenClassification,
        TFDistilBertMainLayer,
        TFDistilBertModel,
        TFDistilBertPreTrainedModel,
    )

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_distilbert import (
        FlaxDistilBertForMaskedLM,
        FlaxDistilBertForMultipleChoice,
        FlaxDistilBertForQuestionAnswering,
        FlaxDistilBertForSequenceClassification,
        FlaxDistilBertForTokenClassification,
        FlaxDistilBertModel,
        FlaxDistilBertPreTrainedModel,
    )

else:
  import sys

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

