


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






    '''simple docstring'''





    A_  :     str			= BlenderbotConfig
    A_  :     Tuple			= {}
    A_  :     str			= 'gelu'





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





       '''simple docstring'''
       UpperCAmelCase_							:      Optional[int]						=   parent
       UpperCAmelCase_							:      Tuple						=   batch_size
       UpperCAmelCase_							:      List[Any]						=   seq_length
       UpperCAmelCase_							:      Any						=   is_training
       UpperCAmelCase_							:      List[Any]						=   use_labels
       UpperCAmelCase_							:      Tuple						=   vocab_size
       UpperCAmelCase_							:      Dict						=   hidden_size
       UpperCAmelCase_							:      List[str]						=   num_hidden_layers
       UpperCAmelCase_							:      Tuple						=   num_attention_heads
       UpperCAmelCase_							:      Any						=   intermediate_size

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





    def 					_lowerCamelCase (	self				:   Tuple	):





       '''simple docstring'''
       UpperCAmelCase_							:      List[Any]						=   ids_tensor([self.batch_size, self.seq_length - 1]       ,   self.vocab_size	)
       UpperCAmelCase_							:      List[str]						=   tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size	)       ,   1	)
       UpperCAmelCase_							:      Dict						=   tf.concat([input_ids, eos_tensor]       ,   axis=1	)

       UpperCAmelCase_							:      Union[str, Any]						=   ids_tensor([self.batch_size, self.seq_length]       ,   self.vocab_size	)

       UpperCAmelCase_							:      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       ,   )
       UpperCAmelCase_							:      int						=   prepare_blenderbot_inputs_dict(__snake_case       ,   __snake_case       ,   __snake_case	)
       return config, inputs_dict





    def 					_lowerCamelCase (	self				:   Tuple       ,   __snake_case				:   List[str]       ,   __snake_case				:   List[str]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Tuple						=   TFBlenderbotModel(config=__snake_case	).get_decoder()
       UpperCAmelCase_							:      Optional[int]						=   inputs_dict['''input_ids''']

       UpperCAmelCase_							:      List[Any]						=   input_ids[:1, :]
       UpperCAmelCase_							:      Union[str, Any]						=   inputs_dict['''attention_mask'''][:1, :]
       UpperCAmelCase_							:      str						=   inputs_dict['''head_mask''']
       UpperCAmelCase_							:      Dict						=   1

       # first forward pass
       UpperCAmelCase_							:      Optional[int]						=   model(__snake_case       ,   attention_mask=__snake_case       ,   head_mask=__snake_case       ,   use_cache=__snake_case	)

       UpperCAmelCase_							:      Optional[int]						=   outputs.to_tuple()

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

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

       UpperCAmelCase_							:      Optional[int]						=   model(__snake_case       ,   attention_mask=__snake_case	)[0]
       UpperCAmelCase_							:      Union[str, Any]						=   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
       UpperCAmelCase_							:      Optional[int]						=   int(ids_tensor((1,)       ,   output_from_past.shape[-1]	)	)
       UpperCAmelCase_							:      List[str]						=   output_from_no_past[:, -3:, random_slice_idx]
       UpperCAmelCase_							:      str						=   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      snake_case_						( __lowercase			,       __lowercase			,       __lowercase			,       __lowercase=None			,       __lowercase=None			,       __lowercase=None			,       __lowercase=None			,       __lowercase=None			,       ):
   if attention_mask is None:
      UpperCAmelCase_							:      Any						=   tf.cast(tf.math.not_equal(__lowercase			,       config.pad_token_id       )			,       tf.inta       )
   if decoder_attention_mask is None:
      UpperCAmelCase_							:      Dict						=   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_							:      Dict						=   tf.ones((config.encoder_layers, config.encoder_attention_heads)       )
   if decoder_head_mask is None:
      UpperCAmelCase_							:      List[Any]						=   tf.ones((config.decoder_layers, config.decoder_attention_heads)       )
   if cross_attn_head_mask is None:
      UpperCAmelCase_							:      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__(    snake_case__    ,    snake_case__    ,    unittest.TestCase						):






    '''simple docstring'''





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





    def 					_lowerCamelCase (	self				:   Tuple	):





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   TFBlenderbotModelTester(self	)
       UpperCAmelCase_							:      List[str]						=   ConfigTester(self       ,   config_class=__snake_case	)





    def 					_lowerCamelCase (	self				:   Optional[Any]	):





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





    def 					_lowerCamelCase (	self				:   int	):





       '''simple docstring'''
       UpperCAmelCase_							:      int						=   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						):






    '''simple docstring'''





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





    @cached_property
    def 					_lowerCamelCase (	self				:   Optional[Any]	):





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





    @cached_property
    def 					_lowerCamelCase (	self				:   Optional[Any]	):





       '''simple docstring'''
       UpperCAmelCase_							:      Any						=   TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name	)
       return model





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





       '''simple docstring'''
       UpperCAmelCase_							:      Dict						=   self.tokenizer(self.src_text       ,   return_tensors='''tf'''	)
       UpperCAmelCase_							:      str						=   self.model.generate(
           model_inputs.input_ids       ,   )
       UpperCAmelCase_							:      Optional[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_torch_available


__UpperCamelCase				:  str      					=							{
    'configuration_x_clip': [
        'XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'XCLIPConfig',
        'XCLIPTextConfig',
        'XCLIPVisionConfig',
    ],
    'processing_x_clip': ['XCLIPProcessor'],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __UpperCamelCase				:  Any      					=							[
           'XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
           'XCLIPModel',
           'XCLIPPreTrainedModel',
           'XCLIPTextModel',
           'XCLIPVisionModel',
       ]

if TYPE_CHECKING:
       from .configuration_x_clip import (
           XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
           XCLIPConfig,
           XCLIPTextConfig,
           XCLIPVisionConfig,
       )
       from .processing_x_clip import XCLIPProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_x_clip import (
                  XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
                  XCLIPModel,
                  XCLIPPreTrainedModel,
                  XCLIPTextModel,
                  XCLIPVisionModel,
              )

else:
       import sys

       __UpperCamelCase				:  List[str]      					=							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)