



'''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 				snake_case :
       lowerCAmelCase__  :Union[str, Any]						   =					BlenderbotConfig
       lowerCAmelCase__  :str						   =					{}
       lowerCAmelCase__  :str						   =					"gelu"



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_=13     ,UpperCAmelCase_=7     ,UpperCAmelCase_=True     ,UpperCAmelCase_=False     ,UpperCAmelCase_=99     ,UpperCAmelCase_=32     ,UpperCAmelCase_=2     ,UpperCAmelCase_=4     ,UpperCAmelCase_=37     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=20     ,UpperCAmelCase_=2     ,UpperCAmelCase_=1     ,UpperCAmelCase_=0     ,)  ->							Optional[Any]:
           lowercase__		       =						parent
           lowercase__		       =						batch_size
           lowercase__		       =						seq_length
           lowercase__		       =						is_training
           lowercase__		       =						use_labels
           lowercase__		       =						vocab_size
           lowercase__		       =						hidden_size
           lowercase__		       =						num_hidden_layers
           lowercase__		       =						num_attention_heads
           lowercase__		       =						intermediate_size

           lowercase__		       =						hidden_dropout_prob
           lowercase__		       =						attention_probs_dropout_prob
           lowercase__		       =						max_position_embeddings
           lowercase__		       =						eos_token_id
           lowercase__		       =						pad_token_id
           lowercase__		       =						bos_token_id



       def 							_a      (				self      )  ->							Dict:
           lowercase__		       =						ids_tensor([self.batch_size, self.seq_length - 1]     ,self.vocab_size      )
           lowercase__		       =						tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size      )     ,1      )
           lowercase__		       =						tf.concat([input_ids, eos_tensor]     ,axis=1      )

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

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







       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							List[Any]:
           lowercase__		       =						TFBlenderbotModel(config=UpperCAmelCase_      ).get_decoder()
           lowercase__		       =						inputs_dict["input_ids"]

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

           # first forward pass
           lowercase__		       =						model(UpperCAmelCase_     ,attention_mask=UpperCAmelCase_     ,head_mask=UpperCAmelCase_     ,use_cache=UpperCAmelCase_      )

           lowercase__       ,       lowercase__		       =						outputs.to_tuple()

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

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

           lowercase__		       =						model(UpperCAmelCase_     ,attention_mask=UpperCAmelCase_      )[0]
           lowercase__		       =						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
           lowercase__		       =						int(ids_tensor((1,)     ,output_from_past.shape[-1]      )      )
           lowercase__		       =						output_from_no_past[:, -3:, random_slice_idx]
           lowercase__		       =						output_from_past[:, :, random_slice_idx]

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





def        lowerCamelCase  (				_snake_case  :						Any     ,_snake_case  :						Optional[int]     ,_snake_case  :						Optional[int]     ,_snake_case  :						Optional[Any]=None     ,_snake_case  :						str=None     ,_snake_case  :						List[str]=None     ,_snake_case  :						str=None     ,_snake_case  :						int=None     ,):





    '''simple docstring'''


    if attention_mask is None:
        lowercase__		       =						tf.cast(tf.math.not_equal(_snake_case     ,config.pad_token_id       )     ,tf.inta       )
    if decoder_attention_mask is None:
        lowercase__		       =						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:
        lowercase__		       =						tf.ones((config.encoder_layers, config.encoder_attention_heads)       )
    if decoder_head_mask is None:
        lowercase__		       =						tf.ones((config.decoder_layers, config.decoder_attention_heads)       )
    if cross_attn_head_mask is None:
        lowercase__		       =						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 				snake_case (UpperCamelCase		,      UpperCamelCase		,      unittest.TestCase   ):
       lowerCAmelCase__  :Optional[int]						   =					(TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
       lowerCAmelCase__  :Any						   =					(TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
       lowerCAmelCase__  :Tuple						   =					(
           {
               "conversational": TFBlenderbotForConditionalGeneration,
               "feature-extraction": TFBlenderbotModel,
               "summarization": TFBlenderbotForConditionalGeneration,
               "text2text-generation": TFBlenderbotForConditionalGeneration,
               "translation": TFBlenderbotForConditionalGeneration,
           }
           if is_tf_available()
           else {}
       )
       lowerCAmelCase__  :Dict						   =					True
       lowerCAmelCase__  :Tuple						   =					False
       lowerCAmelCase__  :str						   =					False



       def 							_a      (				self      )  ->							List[str]:
           lowercase__		       =						TFBlenderbotModelTester(self      )
           lowercase__		       =						ConfigTester(self     ,config_class=UpperCAmelCase_      )



       def 							_a      (				self      )  ->							List[Any]:
           self.config_tester.run_common_tests()







       def 							_a      (				self      )  ->							Union[str, Any]:
           lowercase__		       =						self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.check_decoder_model_past_large_inputs(*UpperCAmelCase_      )





@require_tokenizers
@require_tf
class 				snake_case (unittest.TestCase   ):
       lowerCAmelCase__  :List[str]						   =					["My friends are cool but they eat too many carbs."]
       lowerCAmelCase__  :Optional[int]						   =					"facebook/blenderbot-400M-distill"



       @cached_property
       def 							_a      (				self      )  ->							Union[str, Any]:
           return BlenderbotTokenizer.from_pretrained(self.model_name      )



       @cached_property
       def 							_a      (				self      )  ->							str:
           lowercase__		       =						TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name      )
           return model







       @slow
       def 							_a      (				self      )  ->							int:
           lowercase__		       =						self.tokenizer(self.src_text     ,return_tensors="tf"      )
           lowercase__		       =						self.model.generate(
               model_inputs.input_ids     ,)
           lowercase__		       =						self.tokenizer.batch_decode(generated_ids.numpy()     ,skip_special_tokens=UpperCAmelCase_      )[0]
           assert (
               generated_words
               == " That's unfortunate. Are they trying to lose weight or are they just trying to be healthier?"
           )









'''simple docstring'''





import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


class 				snake_case (unittest.TestCase		,      UpperCamelCase   ):



       def 							_a      (				self      )  ->							List[str]:
           lowercase__		       =						load_tool("text-classification"      )
           self.tool.setup()
           lowercase__		       =						load_tool("text-classification"     ,remote=UpperCAmelCase_      )



       def 							_a      (				self      )  ->							Any:
           lowercase__		       =						self.tool("That's quite cool"     ,["positive", "negative"]      )
           self.assertEqual(UpperCAmelCase_     ,"positive"      )



       def 							_a      (				self      )  ->							Optional[int]:
           lowercase__		       =						self.remote_tool("That's quite cool"     ,["positive", "negative"]      )
           self.assertEqual(UpperCAmelCase_     ,"positive"      )



       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						self.tool(text="That's quite cool"     ,labels=["positive", "negative"]      )
           self.assertEqual(UpperCAmelCase_     ,"positive"      )







       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						self.remote_tool(text="That's quite cool"     ,labels=["positive", "negative"]      )
           self.assertEqual(UpperCAmelCase_     ,"positive"      )




