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"""







  lowerCamelCase__   =  BlenderbotConfig
  lowerCamelCase__   =  {}
  lowerCamelCase__   =  "gelu"







  def __init__(							self       :				Optional[Any]     ,   __magic_name__       :				Tuple     ,   __magic_name__       :				Optional[Any]=13     ,   __magic_name__       :				List[Any]=7     ,   __magic_name__       :				Tuple=True     ,   __magic_name__       :				Tuple=False     ,   __magic_name__       :				Any=99     ,   __magic_name__       :				Union[str, Any]=32     ,   __magic_name__       :				int=2     ,   __magic_name__       :				str=4     ,   __magic_name__       :				str=37     ,   __magic_name__       :				Any=0.1     ,   __magic_name__       :				List[Any]=0.1     ,   __magic_name__       :				Optional[Any]=20     ,   __magic_name__       :				Dict=2     ,   __magic_name__       :				List[str]=1     ,   __magic_name__       :				List[str]=0     ,   )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     parent
        SCREAMING_SNAKE_CASE_      =     batch_size
        SCREAMING_SNAKE_CASE_      =     seq_length
        SCREAMING_SNAKE_CASE_      =     is_training
        SCREAMING_SNAKE_CASE_      =     use_labels
        SCREAMING_SNAKE_CASE_      =     vocab_size
        SCREAMING_SNAKE_CASE_      =     hidden_size
        SCREAMING_SNAKE_CASE_      =     num_hidden_layers
        SCREAMING_SNAKE_CASE_      =     num_attention_heads
        SCREAMING_SNAKE_CASE_      =     intermediate_size

        SCREAMING_SNAKE_CASE_      =     hidden_dropout_prob
        SCREAMING_SNAKE_CASE_      =     attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE_      =     max_position_embeddings
        SCREAMING_SNAKE_CASE_      =     eos_token_id
        SCREAMING_SNAKE_CASE_      =     pad_token_id
        SCREAMING_SNAKE_CASE_      =     bos_token_id







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

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

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







  def       __A   (							self       :				Any     ,   __magic_name__       :				Dict     ,   __magic_name__       :				Tuple      )     ->		Union[str, Any]:
        SCREAMING_SNAKE_CASE_      =     TFBlenderbotModel(config=__magic_name__      ).get_decoder()
        SCREAMING_SNAKE_CASE_      =     inputs_dict['''input_ids''']

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

        # first forward pass
        SCREAMING_SNAKE_CASE_      =     model(__magic_name__     ,   attention_mask=__magic_name__     ,   head_mask=__magic_name__     ,   use_cache=__magic_name__      )

        SCREAMING_SNAKE_CASE_      =     outputs.to_tuple()

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

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

        SCREAMING_SNAKE_CASE_      =     model(__magic_name__     ,   attention_mask=__magic_name__      )[0]
        SCREAMING_SNAKE_CASE_      =     model(__magic_name__     ,   attention_mask=__magic_name__     ,   past_key_values=__magic_name__      )[0]

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

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

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



def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					):
      if attention_mask is None:
            SCREAMING_SNAKE_CASE_      =     tf.cast(tf.math.not_equal(__UpperCAmelCase   ,					config.pad_token_id )   ,					tf.inta )
      if decoder_attention_mask is None:
            SCREAMING_SNAKE_CASE_      =     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:
            SCREAMING_SNAKE_CASE_      =     tf.ones((config.encoder_layers, config.encoder_attention_heads) )
      if decoder_head_mask is None:
            SCREAMING_SNAKE_CASE_      =     tf.ones((config.decoder_layers, config.decoder_attention_heads) )
      if cross_attn_head_mask is None:
            SCREAMING_SNAKE_CASE_      =     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    (__lowerCamelCase     ,					__lowerCamelCase     ,					unittest.TestCase    ):
  """simple docstring"""







  lowerCamelCase__   =  (TFBlenderbotForConditionalGeneration, TFBlenderbotModel) if is_tf_available() else ()
  lowerCamelCase__   =  (TFBlenderbotForConditionalGeneration,) if is_tf_available() else ()
  lowerCamelCase__   =  (
      {
          "conversational": TFBlenderbotForConditionalGeneration,
          "feature-extraction": TFBlenderbotModel,
          "summarization": TFBlenderbotForConditionalGeneration,
          "text2text-generation": TFBlenderbotForConditionalGeneration,
          "translation": TFBlenderbotForConditionalGeneration,
      }
      if is_tf_available()
      else {}
  )
  lowerCamelCase__   =  True
  lowerCamelCase__   =  False
  lowerCamelCase__   =  False







  def       __A   (							self       :				Dict      )     ->		Dict:
        SCREAMING_SNAKE_CASE_      =     TFBlenderbotModelTester(self      )
        SCREAMING_SNAKE_CASE_      =     ConfigTester(self     ,   config_class=__magic_name__      )







  def       __A   (							self       :				Tuple      )     ->		int:
        self.config_tester.run_common_tests()







  def       __A   (							self       :				Union[str, Any]      )     ->		Tuple:
        SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_decoder_model_past_large_inputs(*__magic_name__      )



@require_tokenizers
@require_tf
class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  lowerCamelCase__   =  ["My friends are cool but they eat too many carbs."]
  lowerCamelCase__   =  "facebook/blenderbot-400M-distill"







  @cached_property
  def       __A   (							self       :				List[Any]      )     ->		Tuple:
        return BlenderbotTokenizer.from_pretrained(self.model_name      )







  @cached_property
  def       __A   (							self       :				Union[str, Any]      )     ->		str:
        SCREAMING_SNAKE_CASE_      =     TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name      )
        return model







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









from __future__ import annotations




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int		,   __UpperCAmelCase:			int      )      ->	list[list[int]]:
    UpperCamelCase__							:				list[list[int]]          =      []
    create_all_state(1		,   __UpperCAmelCase		,   __UpperCAmelCase		,   []		,   __UpperCAmelCase      )
    return result




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int		,   __UpperCAmelCase:			int		,   __UpperCAmelCase:			int		,   __UpperCAmelCase:			list[int]		,   __UpperCAmelCase:			list[list[int]]		,   )      ->	None:
    if level == 0:
        total_list.append(current_list[:]      )
        return

    for i in range(__UpperCAmelCase		,   total_number - level + 2      ):
        current_list.append(__UpperCAmelCase      )
        create_all_state(i + 1		,   __UpperCAmelCase		,   level - 1		,   __UpperCAmelCase		,   __UpperCAmelCase      )
        current_list.pop()




def 		lowerCAmelCase_    (  __UpperCAmelCase:			list[list[int]]      )      ->	None:
    for i in total_list:
        print(*__UpperCAmelCase      )


if __name__ == "__main__":
  UpperCAmelCase_     							= 4
  UpperCAmelCase_     							= 2
  UpperCAmelCase_     							= generate_all_combinations(n, k)
  print_all_state(total_list)

