

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



 """simple docstring"""







 _lowercase     :					str      =						BlenderbotConfig
 _lowercase     :					Optional[Any]      =						{}
 _lowercase     :					List[str]      =						'''gelu'''

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






      '''simple docstring'''




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

      _lowerCAmelCase   :					Dict        =    hidden_dropout_prob
      _lowerCAmelCase   :					List[str]        =    attention_probs_dropout_prob
      _lowerCAmelCase   :					List[Any]        =    max_position_embeddings
      _lowerCAmelCase   :					int        =    eos_token_id
      _lowerCAmelCase   :					Union[str, Any]        =    pad_token_id
      _lowerCAmelCase   :					Optional[Any]        =    bos_token_id

 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    ids_tensor([self.batch_size, self.seq_length - 1]     ,						self.vocab_size       )
      _lowerCAmelCase   :					Tuple        =    tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size       )     ,						1       )
      _lowerCAmelCase   :					Dict        =    tf.concat([input_ids, eos_tensor]     ,						axis=1       )

      _lowerCAmelCase   :					Optional[Any]        =    ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size       )

      _lowerCAmelCase   :					Optional[int]        =    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   :					List[Any]        =    prepare_blenderbot_inputs_dict(lowerCamelCase_     ,						lowerCamelCase_     ,						lowerCamelCase_       )
      return config, inputs_dict


 def    __magic_name__       (		self :	Optional[Any]     ,						A_ :	Dict     ,						A_ :	int       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    TFBlenderbotModel(config=lowerCamelCase_       ).get_decoder()
      _lowerCAmelCase   :					List[Any]        =    inputs_dict["""input_ids"""]

      _lowerCAmelCase   :					List[Any]        =    input_ids[:1, :]
      _lowerCAmelCase   :					Tuple        =    inputs_dict["""attention_mask"""][:1, :]
      _lowerCAmelCase   :					Optional[Any]        =    inputs_dict["""head_mask"""]
      _lowerCAmelCase   :					List[str]        =    1

      # first forward pass
      _lowerCAmelCase   :					Optional[Any]        =    model(lowerCamelCase_     ,						attention_mask=lowerCamelCase_     ,						head_mask=lowerCamelCase_     ,						use_cache=lowerCamelCase_       )

      _lowerCAmelCase   :					Union[str, Any]        =    outputs.to_tuple()

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

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

      _lowerCAmelCase   :					Union[str, Any]        =    model(lowerCamelCase_     ,						attention_mask=lowerCamelCase_       )[0]
      _lowerCAmelCase   :					Optional[int]        =    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
      _lowerCAmelCase   :					Optional[int]        =    int(ids_tensor((1,)     ,						output_from_past.shape[-1]       )       )
      _lowerCAmelCase   :					Optional[int]        =    output_from_no_past[:, -3:, random_slice_idx]
      _lowerCAmelCase   :					Any        =    output_from_past[:, :, random_slice_idx]

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







def 	_snake_case		(    SCREAMING_SNAKE_CASE		,							SCREAMING_SNAKE_CASE		,							SCREAMING_SNAKE_CASE		,							SCREAMING_SNAKE_CASE=None		,							SCREAMING_SNAKE_CASE=None		,							SCREAMING_SNAKE_CASE=None		,							SCREAMING_SNAKE_CASE=None		,							SCREAMING_SNAKE_CASE=None		,							)       ->      Tuple:

     """simple docstring"""







     if attention_mask is None:
          _lowerCAmelCase   :					Tuple        =    tf.cast(tf.math.not_equal(lowerCamelCase_		,							config.pad_token_id				)		,							tf.inta				)
     if decoder_attention_mask is None:
          _lowerCAmelCase   :					Tuple        =    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   :					Tuple        =    tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
     if decoder_head_mask is None:
          _lowerCAmelCase   :					Dict        =    tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
     if cross_attn_head_mask is None:
          _lowerCAmelCase   :					Union[str, 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 A__    ( lowercase_  ,		lowercase_  ,		unittest.TestCase ):



 """simple docstring"""







 _lowercase     :					List[str]      =						(TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
 _lowercase     :					Dict      =						(TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
 _lowercase     :					List[str]      =						(
     {
         '''conversational''': TFBlenderbotForConditionalGeneration,
         '''feature-extraction''': TFBlenderbotModel,
         '''summarization''': TFBlenderbotForConditionalGeneration,
         '''text2text-generation''': TFBlenderbotForConditionalGeneration,
         '''translation''': TFBlenderbotForConditionalGeneration,
     }
     if is_tf_available()
     else {}
 )
 _lowercase     :					int      =						True
 _lowercase     :					List[str]      =						False
 _lowercase     :					List[str]      =						False

 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Any        =    TFBlenderbotModelTester(self       )
      _lowerCAmelCase   :					int        =    ConfigTester(self     ,						config_class=lowerCamelCase_       )

 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      self.config_tester.run_common_tests()


 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[str]        =    self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_decoder_model_past_large_inputs(*lowerCamelCase_       )





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



 """simple docstring"""







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

 @cached_property
 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      return BlenderbotTokenizer.from_pretrained(self.model_name       )

 @cached_property
 def    __magic_name__       (		self :	Any       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name       )
      return model


 @slow
 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[Any]        =    self.tokenizer(self.src_text     ,						return_tensors="tf"       )
      _lowerCAmelCase   :					Union[str, Any]        =    self.model.generate(
          model_inputs.input_ids     ,						)
      _lowerCAmelCase   :					Dict        =    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?"
      )









from typing import TYPE_CHECKING

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


__UpperCAmelCase    				=     {
    'configuration_lxmert': ['LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LxmertConfig'],
    'tokenization_lxmert': ['LxmertTokenizer'],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase    				=     ['LxmertTokenizerFast']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase    				=     [
      'LxmertEncoder',
      'LxmertForPreTraining',
      'LxmertForQuestionAnswering',
      'LxmertModel',
      'LxmertPreTrainedModel',
      'LxmertVisualFeatureEncoder',
      'LxmertXLayer',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase    				=     [
      'TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFLxmertForPreTraining',
      'TFLxmertMainLayer',
      'TFLxmertModel',
      'TFLxmertPreTrainedModel',
      'TFLxmertVisualFeatureEncoder',
  ]


if TYPE_CHECKING:
  from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig
  from .tokenization_lxmert import LxmertTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_lxmert_fast import LxmertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_lxmert import (
        LxmertEncoder,
        LxmertForPreTraining,
        LxmertForQuestionAnswering,
        LxmertModel,
        LxmertPreTrainedModel,
        LxmertVisualFeatureEncoder,
        LxmertXLayer,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_lxmert import (
        TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFLxmertForPreTraining,
        TFLxmertMainLayer,
        TFLxmertModel,
        TFLxmertPreTrainedModel,
        TFLxmertVisualFeatureEncoder,
    )

else:
  import sys

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






