from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
		import tensorflow as tf

		from transformers import (
		    AutoTokenizer,
		    TFAutoModelForCausalLM,
		    TFAutoModelForSeqaSeqLM,
		    TFAutoModelForSpeechSeqaSeq,
		    TFAutoModelForVisionaSeq,
		    TFBartForConditionalGeneration,
		    TFLogitsProcessorList,
		    TFMinLengthLogitsProcessor,
		    tf_top_k_top_p_filtering,
		)

if is_tensorflow_text_available():
		import tensorflow_text as text





@require_tf
class 	snake_case__ (							unittest.TestCase				):
	def       __magic_name__    (    self			)							->				str:
							__magic_name__      :       str       						= tf.convert_to_tensor(
							    [
							        [
							            8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
							            -0.5_6_2_0_0_4_4,
							            5.2_3_2_2_9_7_5_2,
							            4.0_3_8_6_3_9_3,
							            -6.8_7_9_8_3_7_8,
							            -0.5_4_7_8_5_8_0_2,
							            -3.2_0_1_2_1_5_3,
							            2.9_2_7_7_7_1_7_6,
							            1.8_8_1_7_1_9_5_3,
							            7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
							            8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
							            -9.8_5_7_1_1_8_3_6,
							            -5.9_6_2_0_9_2_3_6,
							            -1.1_3_0_3_9_1_6_1,
							            -7.1_1_1_5_2_9_4,
							            -0.8_3_6_9_6_3_3,
							            -5.3_1_8_6_4_0_8,
							            7.0_6_4_2_7_4_0_7,
							            0.8_1_3_6_9_3_4_4,
							            -0.8_2_0_2_3_8_1_7,
							            -5.9_1_7_9_7_9_6,
							            0.5_8_8_1_3_4_4_3,
							            -6.9_9_7_7_8_4_3_8,
							            4.7_1_5_5_1_1_8_9,
							            -0.1_8_7_7_1_6_3_7,
							            7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
							            9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
							            2.1_2_6_6_2_9_4_1,
							            -9.3_2_5_6_2_0_3_8,
							            2.3_5_6_5_2_5_2_2,
							        ],  # cummulative prob of 5 highest values <= 0.6
							        [
							            0.5_8_4_2_5_5_1_8,
							            4.5_3_1_3_9_2_3_8,
							            -5.5_7_5_1_0_4_6_4,
							            -6.2_8_0_3_0_6_9_9,
							            -7.1_9_5_2_9_5_0_3,
							            -4.0_2_1_2_2_5_5_1,
							            1.3_9_3_3_7_0_3_7,
							            -6.0_6_7_0_7_0_5_7,
							            1.5_9_4_8_0_5_1_7,
							            -9.6_4_3_1_1_9,
							            0.0_3_9_0_7_7_9_9,
							            0.6_7_2_3_1_7_6_2,
							            -8.8_8_2_0_6_7_2_6,
							            6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
							            2.2_8_5_2_0_7_2_3,
							            4.8_2_7_6_7_5_0_6,
							            4.3_0_4_2_1_3_6_8,
							            8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
							            5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
							            -4.4_7_3_5_7_9_4,
							            7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
							            -2.9_1_0_5_1_6_6_3,
							            2.6_1_9_4_6_0_7_7,
							            -2.5_6_7_4_7_6_2,
							            -9.4_8_9_5_9_3_0_2,
							            -4.0_2_9_2_2_6_4_5,
							            -1.3_5_4_1_6_9_1_8,
							            9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
							            -5.8_9_4_7_8_5_5_3,
							            1.8_5_3_7_0_4_6_7,
							        ],  # cummulative prob of 5 highest values <= 0.6
							    ]      ,       dtype=tf.floataa      ,       )

							__magic_name__      :       List[str]       						= tf.convert_to_tensor(
							    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]      ,       dtype=tf.intaa      ,       )  # expected non filtered idx as noted above

							__magic_name__      :       Optional[Any]       						= tf.convert_to_tensor(
							    [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]      ,       dtype=tf.floataa      ,       )  # expected non filtered values as noted above

							__magic_name__      :       List[str]       						= tf_top_k_top_p_filtering(_a      ,       top_k=10      ,       top_p=0.6      ,       min_tokens_to_keep=4			)

							__magic_name__      :       Optional[int]       						= output[output != -float("""inf"""			)]
							__magic_name__      :       Union[str, Any]       						= tf.cast(
							    tf.where(tf.not_equal(_a      ,       tf.constant(-float("""inf"""			)      ,       dtype=tf.floataa			)			)			)      ,       dtype=tf.intaa      ,       )

							tf.debugging.assert_near(_a      ,       _a      ,       rtol=1e-1_2			)
							tf.debugging.assert_equal(_a      ,       _a			)





@require_tf
class 	snake_case__ (							unittest.TestCase						,  _lowerCAmelCase				):


	if is_tf_available():
		lowercase__						:					Tuple											=   {
		    '''AutoModelForCausalLM''': TFAutoModelForCausalLM,
		    '''AutoModelForSpeechSeq2Seq''': TFAutoModelForSpeechSeqaSeq,
		    '''AutoModelForSeq2SeqLM''': TFAutoModelForSeqaSeqLM,
		    '''AutoModelForVision2Seq''': TFAutoModelForVisionaSeq,
		    '''LogitsProcessorList''': TFLogitsProcessorList,
		    '''MinLengthLogitsProcessor''': TFMinLengthLogitsProcessor,
		    '''create_tensor_fn''': tf.convert_to_tensor,
		    '''floats_tensor''': floats_tensor,
		    '''return_tensors''': '''tf''',
		}
	@slow
	def       __magic_name__    (    self			)							->				Optional[int]:
							# TF-only test: tf.saved_model export
							__magic_name__      :       Dict       						= TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""			)
							__magic_name__      :       Tuple       						= 2
							__magic_name__      :       List[str]       						= 2





							class 	snake_case__ (							tf.Module				):
								def __init__(    self      ,       lowerCAmelCase__			)							->				str:
														super(_a      ,       self			).__init__()
														__magic_name__      :       List[str]       						= model







								@tf.function(
								    input_signature=(
								        tf.TensorSpec((None, input_length)      ,       tf.intaa      ,       name="""input_ids"""			),
								        tf.TensorSpec((None, input_length)      ,       tf.intaa      ,       name="""attention_mask"""			),
								    )      ,       jit_compile=_a      ,       )
								def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__			)							->				List[str]:
														__magic_name__      :       Optional[Any]       						= self.model.generate(
														    input_ids=_a      ,       attention_mask=_a      ,       max_new_tokens=_a      ,       return_dict_in_generate=_a      ,       )
														return {"sequences": outputs["sequences"]}



							__magic_name__      :       List[Any]       						= [[2, 0], [1_02, 1_03]]
							__magic_name__      :       Optional[int]       						= [[1, 0], [1, 1]]
							__magic_name__      :       Tuple       						= DummyModel(model=_a			)
							with tempfile.TemporaryDirectory() as tmp_dir:
													tf.saved_model.save(_a      ,       _a      ,       signatures={"""serving_default""": dummy_model.serving}			)
													__magic_name__      :       Union[str, Any]       						= tf.saved_model.load(_a			).signatures["""serving_default"""]
													for batch_size in range(1      ,       len(_a			) + 1			):
																			__magic_name__      :       Tuple       						= {
																			    """input_ids""": tf.constant(dummy_input_ids[:batch_size]			),
																			    """attention_mask""": tf.constant(dummy_attention_masks[:batch_size]			),
																			}
																			__magic_name__      :       Dict       						= serving_func(**_a			)["""sequences"""]
																			__magic_name__      :       Optional[int]       						= test_model.generate(**_a      ,       max_new_tokens=_a			)
																			tf.debugging.assert_equal(_a      ,       _a			)
	@slow
	def       __magic_name__    (    self			)							->				Optional[int]:
							# TF-only test: tf.saved_model export
							__magic_name__      :       Any       						= TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""			)
							__magic_name__      :       Any       						= 1
							__magic_name__      :       Union[str, Any]       						= 2





							class 	snake_case__ (							tf.Module				):
								def __init__(    self      ,       lowerCAmelCase__			)							->				Union[str, Any]:
														super(_a      ,       self			).__init__()
														__magic_name__      :       Any       						= model







								@tf.function(
								    input_signature=(
								        tf.TensorSpec((batch_size, None)      ,       tf.intaa      ,       name="""input_ids"""			),
								        tf.TensorSpec((batch_size, None)      ,       tf.intaa      ,       name="""attention_mask"""			),
								    )      ,       jit_compile=_a      ,       )
								def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__			)							->				Dict:
														__magic_name__      :       Optional[Any]       						= self.model.generate(
														    input_ids=_a      ,       attention_mask=_a      ,       max_new_tokens=_a      ,       return_dict_in_generate=_a      ,       )
														return {"sequences": outputs["sequences"]}



							__magic_name__      :       List[Any]       						= [[2], [1_02, 1_03]]
							__magic_name__      :       Tuple       						= [[1], [1, 1]]
							__magic_name__      :       Any       						= DummyModel(model=_a			)
							with tempfile.TemporaryDirectory() as tmp_dir:
													tf.saved_model.save(_a      ,       _a      ,       signatures={"""serving_default""": dummy_model.serving}			)
													__magic_name__      :       str       						= tf.saved_model.load(_a			).signatures["""serving_default"""]
													for input_row in range(len(_a			)			):
																			__magic_name__      :       List[str]       						= {
																			    """input_ids""": tf.constant([dummy_input_ids[input_row]]			),
																			    """attention_mask""": tf.constant([dummy_attention_masks[input_row]]			),
																			}
																			__magic_name__      :       List[str]       						= serving_func(**_a			)["""sequences"""]
																			__magic_name__      :       int       						= test_model.generate(**_a      ,       max_new_tokens=_a			)
																			tf.debugging.assert_equal(_a      ,       _a			)
	@slow
	@require_tensorflow_text
	def       __magic_name__    (    self			)							->				Optional[Any]:
							# TF-only test: tf.saved_model export
							with tempfile.TemporaryDirectory() as tmp_dir:
													# file needed to load the TF tokenizer
													hf_hub_download(repo_id="""google/flan-t5-small"""      ,       filename="""spiece.model"""      ,       local_dir=_a			)





													class 	snake_case__ (							tf.keras.layers.Layer				):
														def __init__(    self			)							->				str:
																				super().__init__()
																				__magic_name__      :       Union[str, Any]       						= text.SentencepieceTokenizer(
																				    model=tf.io.gfile.GFile(os.path.join(_a      ,       """spiece.model"""			)      ,       """rb"""			).read()			)
																				__magic_name__      :       Any       						= TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""			)







														def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       *lowerCAmelCase__      ,       **lowerCAmelCase__			)							->				Optional[Any]:
																				__magic_name__      :       int       						= self.tokenizer.tokenize(_a			)
																				__magic_name__						,__magic_name__      :       List[str]       						= text.pad_model_inputs(
																				    _a      ,       max_seq_length=64      ,       pad_value=self.model.config.pad_token_id			)
																				__magic_name__      :       Optional[int]       						= self.model.generate(input_ids=_a      ,       attention_mask=_a			)
																				return self.tokenizer.detokenize(_a			)



													__magic_name__      :       Optional[int]       						= CompleteSentenceTransformer()
													__magic_name__      :       Union[str, Any]       						= tf.keras.layers.Input(shape=(1,)      ,       dtype=tf.string      ,       name="""inputs"""			)
													__magic_name__      :       List[Any]       						= complete_model(_a			)
													__magic_name__      :       str       						= tf.keras.Model(_a      ,       _a			)
													keras_model.save(_a			)
	def       __magic_name__    (    self			)							->				int:
							# Has PT equivalent: this test relies on random sampling
							__magic_name__      :       Optional[int]       						= {
							    """do_sample""": True,
							    """num_beams""": 1,
							    """top_p""": 0.7,
							    """top_k""": 10,
							    """temperature""": 0.7,
							}
							__magic_name__      :       List[str]       						= 14

							__magic_name__      :       str       						= AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""			)
							__magic_name__      :       List[str]       						= """Hello, my dog is cute and"""
							__magic_name__      :       Union[str, Any]       						= tokenizer(_a      ,       return_tensors="""tf"""			)
							__magic_name__      :       str       						= TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""			)

							__magic_name__      :       Union[str, Any]       						= 6_38
							# forces the generation to happen on CPU, to avoid GPU-related quirks
							with tf.device(""":/CPU:0"""			):
													tf.random.set_seed(0			)
													__magic_name__      :       List[str]       						= model.generate(**_a      ,       eos_token_id=_a      ,       **_a			)
							self.assertTrue(expectation == len(generated_tokens[0]			)			)

							__magic_name__      :       Dict       						= [6_38, 1_98]
							with tf.device(""":/CPU:0"""			):
													tf.random.set_seed(0			)
													__magic_name__      :       Optional[int]       						= model.generate(**_a      ,       eos_token_id=_a      ,       **_a			)
							self.assertTrue(expectation == len(generated_tokens[0]			)			)







	def       __magic_name__    (    self			)							->				List[str]:
							# Has PT equivalent: ample use of framework-specific code
							__magic_name__      :       Union[str, Any]       						= AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""			)
							__magic_name__      :       Optional[Any]       						= """Hugging Face is a technology company based in New York and Paris."""
							__magic_name__      :       Optional[Any]       						= bart_tokenizer(_a      ,       return_tensors="""tf"""			).input_ids
							__magic_name__      :       List[Any]       						= TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""			)
							__magic_name__      :       Optional[Any]       						= bart_model.generate(_a			).numpy()





							class 	snake_case__ (							_lowerCAmelCase				):
								def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__=None      ,       **lowerCAmelCase__			)							->				int:
														return super().call(_a      ,       **_a			)



							__magic_name__      :       int       						= FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""			)
							__magic_name__      :       List[str]       						= bart_model.generate(_a      ,       foo="""bar"""			).numpy()
							self.assertTrue(np.array_equal(_a      ,       _a			)			)





							class 	snake_case__ (							bart_model.model.encoder.__class__				):
								def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       **lowerCAmelCase__			)							->				str:
														return super().call(_a      ,       **_a			)



							__magic_name__      :       Optional[int]       						= FakeEncoder(bart_model.config      ,       bart_model.model.shared			)
							__magic_name__      :       Dict       						= fake_encoder

							# Normal generation still works (the output will be different because the encoder weights are different)
							__magic_name__      :       List[Any]       						= bart_model.generate(_a			).numpy()
							with self.assertRaises(_a			):
													# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
													bart_model.generate(_a      ,       foo="""bar"""			)








import unittest

from transformers import is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, require_torch, slow


if is_flax_available():
		import optax
		from flax.training.common_utils import onehot

		from transformers import AutoTokenizer, FlaxMTaForConditionalGeneration
		from transformers.models.ta.modeling_flax_ta import shift_tokens_right





@require_torch
@require_sentencepiece
@require_tokenizers
@require_flax
class 	snake_case__ (							unittest.TestCase				):
	@slow
	def       __magic_name__    (    self			)							->				Optional[Any]:
							__magic_name__      :       Any       						= FlaxMTaForConditionalGeneration.from_pretrained("""google/mt5-small"""			)
							__magic_name__      :       Dict       						= AutoTokenizer.from_pretrained("""google/mt5-small"""			)

							__magic_name__      :       Tuple       						= tokenizer("""Hello there"""      ,       return_tensors="""np"""			).input_ids
							__magic_name__      :       List[Any]       						= tokenizer("""Hi I am"""      ,       return_tensors="""np"""			).input_ids

							__magic_name__      :       Any       						= shift_tokens_right(lowerCAmelCase__      ,       model.config.pad_token_id      ,       model.config.decoder_start_token_id			)

							__magic_name__      :       List[Any]       						= model(lowerCAmelCase__      ,       decoder_input_ids=lowerCAmelCase__			).logits
							__magic_name__      :       Tuple       						= optax.softmax_cross_entropy(lowerCAmelCase__      ,       onehot(lowerCAmelCase__      ,       logits.shape[-1]			)			).mean()

							__magic_name__      :       List[Any]       						= -(labels.shape[-1] * loss.item())

							__magic_name__      :       List[Any]       						= -8_4.9_1_2_7
							self.assertTrue(abs(mtf_score - EXPECTED_SCORE			) < 1e-4			)
