

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 					a__						:
			"""simple docstring"""







			__lowerCamelCase        =       BlenderbotSmallConfig
			__lowerCamelCase        =       {}
			__lowerCamelCase        =       'gelu'


			def __init__(    self      ,      lowercase      ,      lowercase=13      ,      lowercase=7      ,      lowercase=True      ,      lowercase=False      ,      lowercase=99      ,      lowercase=32      ,      lowercase=2      ,      lowercase=4      ,      lowercase=37      ,      lowercase=0.1      ,      lowercase=0.1      ,      lowercase=20      ,      lowercase=2      ,      lowercase=1      ,      lowercase=0      ,      )  ->						Dict:
							'''simple docstring'''






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

							A__        =			hidden_dropout_prob
							A__        =			attention_probs_dropout_prob
							A__        =			max_position_embeddings
							A__        =			eos_token_id
							A__        =			pad_token_id
							A__        =			bos_token_id


			def      UpperCamelCase		(    self       )  ->						Tuple:
							'''simple docstring'''






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

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

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


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase       )  ->						Any:
							'''simple docstring'''






							A__        =			TFBlenderbotSmallModel(config=_a       ).get_decoder()
							A__        =			inputs_dict["input_ids"]

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

							# first forward pass
							A__        =			model(_a      ,      attention_mask=_a      ,      head_mask=_a      ,      use_cache=_a       )

							A__    ,				A__        =			outputs.to_tuple()

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

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

							A__        =			model(_a      ,      attention_mask=_a       )[0]
							A__        =			model(_a      ,      attention_mask=_a      ,      past_key_values=_a       )[0]

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

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

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



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							Optional[Any]	,       SCREAMING_SNAKE_CASE_:							Optional[int]	,       SCREAMING_SNAKE_CASE_:							Dict	,       SCREAMING_SNAKE_CASE_:							Any=None	,       SCREAMING_SNAKE_CASE_:							str=None	,       SCREAMING_SNAKE_CASE_:							Dict=None	,       SCREAMING_SNAKE_CASE_:							Optional[int]=None	,       SCREAMING_SNAKE_CASE_:							str=None	,       )			->      Dict:




				'''simple docstring'''





				if attention_mask is None:
								A__        =			tf.cast(tf.math.not_equal(lowerCAmelCase__	,       config.pad_token_id      )	,       tf.inta      )
				if decoder_attention_mask is None:
								A__        =			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:
								A__        =			tf.ones((config.encoder_layers, config.encoder_attention_heads)      )
				if decoder_head_mask is None:
								A__        =			tf.ones((config.decoder_layers, config.decoder_attention_heads)      )
				if cross_attn_head_mask is None:
								A__        =			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__						(					__SCREAMING_SNAKE_CASE							,	__SCREAMING_SNAKE_CASE							,	unittest.TestCase			):
			"""simple docstring"""







			__lowerCamelCase        =       (
			    (TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel) if is_tf_available() else ()
			)
			__lowerCamelCase        =       (TFBlenderbotSmallForConditionalGeneration,) if is_tf_available() else ()
			__lowerCamelCase        =       (
			    {
			        'conversational': TFBlenderbotSmallForConditionalGeneration,
			        'feature-extraction': TFBlenderbotSmallModel,
			        'summarization': TFBlenderbotSmallForConditionalGeneration,
			        'text2text-generation': TFBlenderbotSmallForConditionalGeneration,
			        'translation': TFBlenderbotSmallForConditionalGeneration,
			    }
			    if is_tf_available()
			    else {}
			)
			__lowerCamelCase        =       True
			__lowerCamelCase        =       False
			__lowerCamelCase        =       False


			def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
							'''simple docstring'''






							A__        =			TFBlenderbotSmallModelTester(self       )
							A__        =			ConfigTester(self      ,      config_class=_a       )


			def      UpperCamelCase		(    self       )  ->						Dict:
							'''simple docstring'''






							self.config_tester.run_common_tests()


			def      UpperCamelCase		(    self       )  ->						str:
							'''simple docstring'''






							A__        =			self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*_a       )

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







			__lowerCamelCase        =       [
			    '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?'
			]
			__lowerCamelCase        =       'facebook/blenderbot_small-90M'


			@cached_property
			def      UpperCamelCase		(    self       )  ->						Optional[int]:
							'''simple docstring'''






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


			@cached_property
			def      UpperCamelCase		(    self       )  ->						Optional[int]:
							'''simple docstring'''






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


			@slow
			def      UpperCamelCase		(    self       )  ->						Optional[int]:
							'''simple docstring'''






							A__        =			self.tokenizer(self.src_text      ,      return_tensors="tf"       )
							A__        =			self.model.generate(
							    model_inputs.input_ids      ,      attention_mask=model_inputs.attention_mask      ,      num_beams=2      ,      use_cache=_a      ,      )
							A__        =			self.tokenizer.batch_decode(generated_ids.numpy()      ,      skip_special_tokens=_a       )[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.",
							)




import datasets

from .evaluate import evaluate


lowerCAmelCase__	   = """\
@inproceedings{Rajpurkar2016SQuAD10,
  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},
  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},
  booktitle={EMNLP},
  year={2016}
}
"""

lowerCAmelCase__	   = """
This metric wrap the official scoring script for version 1 of the Stanford Question Answering Dataset (SQuAD).

Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by
crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,
from the corresponding reading passage, or the question might be unanswerable.
"""

lowerCAmelCase__	   = """
Computes SQuAD scores (F1 and EM).
Args:
    predictions: List of question-answers dictionaries with the following key-values:
        - 'id': id of the question-answer pair as given in the references (see below)
        - 'prediction_text': the text of the answer
    references: List of question-answers dictionaries with the following key-values:
        - 'id': id of the question-answer pair (see above),
        - 'answers': a Dict in the SQuAD dataset format
            {
                'text': list of possible texts for the answer, as a list of strings
                'answer_start': list of start positions for the answer, as a list of ints
            }
            Note that answer_start values are not taken into account to compute the metric.
Returns:
    'exact_match': Exact match (the normalized answer exactly match the gold answer)
    'f1': The F-score of predicted tokens versus the gold answer
Examples:

    >>> predictions = [{'prediction_text': '1976', 'id': '56e10a3be3433e1400422b22'}]
    >>> references = [{'answers': {'answer_start': [97], 'text': ['1976']}, 'id': '56e10a3be3433e1400422b22'}]
    >>> squad_metric = datasets.load_metric(\"squad\")
    >>> results = squad_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 100.0, 'f1': 100.0}
"""

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,	_KWARGS_DESCRIPTION			)
class 					a__						(					datasets.Metric			):
			"""simple docstring"""







			def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
							'''simple docstring'''






							return datasets.MetricInfo(
							    description=_DESCRIPTION      ,      citation=_CITATION      ,      inputs_description=_KWARGS_DESCRIPTION      ,      features=datasets.Features(
							        {
							            "predictions": {"id": datasets.Value("string"       ), "prediction_text": datasets.Value("string"       )},
							            "references": {
							                "id": datasets.Value("string"       ),
							                "answers": datasets.features.Sequence(
							                    {
							                        "text": datasets.Value("string"       ),
							                        "answer_start": datasets.Value("int32"       ),
							                    }       ),
							            },
							        }       )      ,      codebase_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]      ,      reference_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]      ,      )


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase       )  ->						Union[str, Any]:
							'''simple docstring'''






							A__        =			{prediction["id"]: prediction["prediction_text"] for prediction in predictions}
							A__        =			[
							    {
							        "paragraphs": [
							            {
							                "qas": [
							                    {
							                        "answers": [{"text": answer_text} for answer_text in ref["answers"]["text"]],
							                        "id": ref["id"],
							                    }
							                    for ref in references
							                ]
							            }
							        ]
							    }
							]
							A__        =			evaluate(dataset=lowercase      ,      predictions=lowercase       )
							return score

