
"""simple docstring"""

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 __lowerCAmelCase	:
     lowercase		     =		BlenderbotSmallConfig
     lowercase		     =		{}
     lowercase		     =		"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			,  ):

      '''simple docstring'''




      __UpperCamelCase       						= parent
      __UpperCamelCase       						= batch_size
      __UpperCamelCase       						= seq_length
      __UpperCamelCase       						= is_training
      __UpperCamelCase       						= use_labels
      __UpperCamelCase       						= vocab_size
      __UpperCamelCase       						= hidden_size
      __UpperCamelCase       						= num_hidden_layers
      __UpperCamelCase       						= num_attention_heads
      __UpperCamelCase       						= intermediate_size

      __UpperCamelCase       						= hidden_dropout_prob
      __UpperCamelCase       						= attention_probs_dropout_prob
      __UpperCamelCase       						= max_position_embeddings
      __UpperCamelCase       						= eos_token_id
      __UpperCamelCase       						= pad_token_id
      __UpperCamelCase       						= bos_token_id





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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

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

      __UpperCamelCase       						= 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       						= prepare_blenderbot_small_inputs_dict(__UpperCAmelCase			,  __UpperCAmelCase			,  __UpperCAmelCase   )
      return config, inputs_dict







     def 		UpperCAmelCase      (			self			,  __UpperCAmelCase			,  __UpperCAmelCase   ):

      '''simple docstring'''




      __UpperCamelCase       						= TFBlenderbotSmallModel(config=__UpperCAmelCase   ).get_decoder()
      __UpperCamelCase       						= inputs_dict['input_ids']

      __UpperCamelCase       						= input_ids[:1, :]
      __UpperCamelCase       						= inputs_dict['attention_mask'][:1, :]
      __UpperCamelCase       						= inputs_dict['head_mask']
      __UpperCamelCase       						= 1

      # first forward pass
      __UpperCamelCase       						= model(__UpperCAmelCase			,  attention_mask=__UpperCAmelCase			,  head_mask=__UpperCAmelCase			,  use_cache=__UpperCAmelCase   )

      __UpperCamelCase						,			__UpperCamelCase       						= outputs.to_tuple()

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

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

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

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






def 							A		(       snake_case   :List[Any]       ,      snake_case   :Dict       ,      snake_case   :Optional[Any]       ,      snake_case   :List[str]=None       ,      snake_case   :Any=None       ,      snake_case   :int=None       ,      snake_case   :Any=None       ,      snake_case   :Tuple=None       ,      )   ->			Union[str, Any]:
 if attention_mask is None:
  __UpperCamelCase       						= tf.cast(tf.math.not_equal(snake_case       ,      config.pad_token_id	)       ,      tf.inta	)
 if decoder_attention_mask is None:
  __UpperCamelCase       						= 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       						= tf.ones((config.encoder_layers, config.encoder_attention_heads)	)
 if decoder_head_mask is None:
  __UpperCamelCase       						= tf.ones((config.decoder_layers, config.decoder_attention_heads)	)
 if cross_attn_head_mask is None:
  __UpperCamelCase       						= 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	(   __SCREAMING_SNAKE_CASE    ,						__SCREAMING_SNAKE_CASE    ,						unittest.TestCase    ):
     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 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= TFBlenderbotSmallModelTester(self   )
      __UpperCamelCase       						= ConfigTester(self			,  config_class=__UpperCAmelCase   )





     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      self.config_tester.run_common_tests()







     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_decoder_model_past_large_inputs(*__UpperCAmelCase   )


@require_tokenizers
@require_tf
class __lowerCAmelCase	(   unittest.TestCase    ):
     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 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




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





     @cached_property
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name   )
      return model







     @slow
     def 		UpperCAmelCase      (			self   ):

      '''simple docstring'''




      __UpperCamelCase       						= self.tokenizer(self.src_text			,  return_tensors='tf'   )
      __UpperCamelCase       						= self.model.generate(
          model_inputs.input_ids			,  attention_mask=model_inputs.attention_mask			,  num_beams=2			,  use_cache=__UpperCAmelCase			,  )
      __UpperCamelCase       						= 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"""

def 							A		(       snake_case   :int       ,      snake_case   :int	)   ->			int:
 return int(input_a == input_a == 0	)






def 							A		(       )   ->			None:
 print('Truth Table of NOR Gate:'	)
 print('|   Input 1   |  Input 2  | Output |'	)
 print(f'|      0      |    0      |  {nor_gate(0       ,      0	)}     |'	)
 print(f'|      0      |    1      |  {nor_gate(0       ,      1	)}     |'	)
 print(f'|      1      |    0      |  {nor_gate(1       ,      0	)}     |'	)
 print(f'|      1      |    1      |  {nor_gate(1       ,      1	)}     |'	)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      main()



