"""simple docstring"""
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 					lowerCAmelCase_      (     unittest.TestCase   ):



				"""simple docstring"""

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     tf.convert_to_tensor(
										    [
										        [
										            8.2_22_09_91,  # 3rd highest value; idx. 0
										            -0.5_62_00_44,
										            5.23_22_97_52,
										            4.0_38_63_93,
										            -6.8_79_83_78,
										            -0.54_78_58_02,
										            -3.2_01_21_53,
										            2.92_77_71_76,
										            1.88_17_19_53,
										            7.35_34_12_76,  # 5th highest value; idx. 9
										            8.43_20_78_33,  # 2nd highest value; idx. 10
										            -9.85_71_18_36,
										            -5.96_20_92_36,
										            -1.13_03_91_61,
										            -7.1_11_52_94,
										            -0.8_36_96_33,
										            -5.3_18_64_08,
										            7.06_42_74_07,
										            0.81_36_93_44,
										            -0.82_02_38_17,
										            -5.9_17_97_96,
										            0.58_81_34_43,
										            -6.99_77_84_38,
										            4.71_55_11_89,
										            -0.18_77_16_37,
										            7.44_02_07_59,  # 4th highest value; idx. 25
										            9.38_45_09_87,  # 1st highest value; idx. 26
										            2.12_66_29_41,
										            -9.32_56_20_38,
										            2.35_65_25_22,
										        ],  # cummulative prob of 5 highest values <= 0.6
										        [
										            0.58_42_55_18,
										            4.53_13_92_38,
										            -5.57_51_04_64,
										            -6.28_03_06_99,
										            -7.19_52_95_03,
										            -4.02_12_25_51,
										            1.39_33_70_37,
										            -6.06_70_70_57,
										            1.59_48_05_17,
										            -9.64_31_19,
										            0.03_90_77_99,
										            0.67_23_17_62,
										            -8.88_20_67_26,
										            6.27_11_59_22,  # 4th highest value; idx. 13
										            2.28_52_07_23,
										            4.82_76_75_06,
										            4.30_42_13_68,
										            8.8_27_53_13,  # 2nd highest value; idx. 17
										            5.44_02_99_58,  # 5th highest value; idx. 18
										            -4.4_73_57_94,
										            7.38_57_95_36,  # 3rd highest value; idx. 20
										            -2.91_05_16_63,
										            2.61_94_60_77,
										            -2.5_67_47_62,
										            -9.48_95_93_02,
										            -4.02_92_26_45,
										            -1.35_41_69_18,
										            9.67_70_23_23,  # 1st highest value; idx. 27
										            -5.89_47_85_53,
										            1.85_37_04_67,
										        ],  # cummulative prob of 5 highest values <= 0.6
										    ]						,      dtype=tf.floataa						,      )

										snake_case        =     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

										snake_case        =     tf.convert_to_tensor(
										    [8.22_20_99, 7.3_53_41_26, 8.43_20_78, 7.4_40_20_75, 9.3_84_51, 6.27_11_59, 8.82_75_31, 5.4_40_29_95, 7.3_85_79_56, 9.67_70_23]						,      dtype=tf.floataa						,      )  # expected non filtered values as noted above

										snake_case        =     tf_top_k_top_p_filtering(lowerCAmelCase						,      top_k=10						,      top_p=0.6						,      min_tokens_to_keep=4      )

										snake_case        =     output[output != -float('inf'      )]
										snake_case        =     tf.cast(
										    tf.where(tf.not_equal(lowerCAmelCase						,      tf.constant(-float('inf'      )						,      dtype=tf.floataa      )      )      )						,      dtype=tf.intaa						,      )

										tf.debugging.assert_near(lowerCAmelCase						,      lowerCAmelCase						,      rtol=1E-12      )
										tf.debugging.assert_equal(lowerCAmelCase						,      lowerCAmelCase      )





@require_tf
class 					lowerCAmelCase_      (     unittest.TestCase       ,      lowerCAmelCase   ):



				"""simple docstring"""
				# setting framework_dependent_parameters needs to be gated, just like its contents' imports
				if is_tf_available():
								_lowerCAmelCase       :      Optional[Any]     					=  {
								    """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 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'      )
										snake_case        =     2
										snake_case        =     2



										class 					lowerCAmelCase_      (     tf.Module   ):



														"""simple docstring"""

														def __init__(			self						,      lowerCAmelCase      ):






																				"""simple docstring"""

																				super(lowerCAmelCase						,      self      ).__init__()
																				snake_case        =     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=lowerCAmelCase						,      )
														def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase      ):






																				"""simple docstring"""

																				snake_case        =     self.model.generate(
																				    input_ids=lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      max_new_tokens=lowerCAmelCase						,      return_dict_in_generate=lowerCAmelCase						,      )
																				return {"sequences": outputs["sequences"]}





										snake_case        =     [[2, 0], [1_02, 1_03]]
										snake_case        =     [[1, 0], [1, 1]]
										snake_case        =     DummyModel(model=lowerCAmelCase      )
										with tempfile.TemporaryDirectory() as tmp_dir:
																tf.saved_model.save(lowerCAmelCase						,      lowerCAmelCase						,      signatures={'serving_default': dummy_model.serving}      )
																snake_case        =     tf.saved_model.load(lowerCAmelCase      ).signatures['serving_default']
																for batch_size in range(1						,      len(lowerCAmelCase      ) + 1      ):
																						snake_case        =     {
																						    'input_ids': tf.constant(dummy_input_ids[:batch_size]      ),
																						    'attention_mask': tf.constant(dummy_attention_masks[:batch_size]      ),
																						}
																						snake_case        =     serving_func(**lowerCAmelCase      )['sequences']
																						snake_case        =     test_model.generate(**lowerCAmelCase						,      max_new_tokens=lowerCAmelCase      )
																						tf.debugging.assert_equal(lowerCAmelCase						,      lowerCAmelCase      )

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'      )
										snake_case        =     1
										snake_case        =     2



										class 					lowerCAmelCase_      (     tf.Module   ):



														"""simple docstring"""

														def __init__(			self						,      lowerCAmelCase      ):






																				"""simple docstring"""

																				super(lowerCAmelCase						,      self      ).__init__()
																				snake_case        =     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=lowerCAmelCase						,      )
														def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase      ):






																				"""simple docstring"""

																				snake_case        =     self.model.generate(
																				    input_ids=lowerCAmelCase						,      attention_mask=lowerCAmelCase						,      max_new_tokens=lowerCAmelCase						,      return_dict_in_generate=lowerCAmelCase						,      )
																				return {"sequences": outputs["sequences"]}





										snake_case        =     [[2], [1_02, 1_03]]
										snake_case        =     [[1], [1, 1]]
										snake_case        =     DummyModel(model=lowerCAmelCase      )
										with tempfile.TemporaryDirectory() as tmp_dir:
																tf.saved_model.save(lowerCAmelCase						,      lowerCAmelCase						,      signatures={'serving_default': dummy_model.serving}      )
																snake_case        =     tf.saved_model.load(lowerCAmelCase      ).signatures['serving_default']
																for input_row in range(len(lowerCAmelCase      )      ):
																						snake_case        =     {
																						    'input_ids': tf.constant([dummy_input_ids[input_row]]      ),
																						    'attention_mask': tf.constant([dummy_attention_masks[input_row]]      ),
																						}
																						snake_case        =     serving_func(**lowerCAmelCase      )['sequences']
																						snake_case        =     test_model.generate(**lowerCAmelCase						,      max_new_tokens=lowerCAmelCase      )
																						tf.debugging.assert_equal(lowerCAmelCase						,      lowerCAmelCase      )

				@slow
				@require_tensorflow_text
				def 						snake_case	(			self      ):






										"""simple docstring"""

										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=lowerCAmelCase      )



																class 					lowerCAmelCase_      (     tf.keras.layers.Layer   ):



																				"""simple docstring"""

																				def __init__(			self      ):






																										"""simple docstring"""

																										super().__init__()
																										snake_case        =     text.SentencepieceTokenizer(
																										    model=tf.io.gfile.GFile(os.path.join(lowerCAmelCase						,      'spiece.model'      )						,      'rb'      ).read()      )
																										snake_case        =     TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'      )

																				def 						snake_case	(			self						,      lowerCAmelCase						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






																										"""simple docstring"""

																										snake_case        =     self.tokenizer.tokenize(lowerCAmelCase      )
																										snake_case   ,snake_case        =     text.pad_model_inputs(
																										    lowerCAmelCase						,      max_seq_length=64						,      pad_value=self.model.config.pad_token_id      )
																										snake_case        =     self.model.generate(input_ids=lowerCAmelCase						,      attention_mask=lowerCAmelCase      )
																										return self.tokenizer.detokenize(lowerCAmelCase      )





																snake_case        =     CompleteSentenceTransformer()
																snake_case        =     tf.keras.layers.Input(shape=(1,)						,      dtype=tf.string						,      name='inputs'      )
																snake_case        =     complete_model(lowerCAmelCase      )
																snake_case        =     tf.keras.Model(lowerCAmelCase						,      lowerCAmelCase      )
																keras_model.save(lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     {
										    'do_sample': True,
										    'num_beams': 1,
										    'top_p': 0.7,
										    'top_k': 10,
										    'temperature': 0.7,
										}
										snake_case        =     14

										snake_case        =     AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'      )
										snake_case        =     'Hello, my dog is cute and'
										snake_case        =     tokenizer(lowerCAmelCase						,      return_tensors='tf'      )
										snake_case        =     TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'      )

										snake_case        =     6_38
										# forces the generation to happen on CPU, to avoid GPU-related quirks
										with tf.device(':/CPU:0'      ):
																tf.random.set_seed(0      )
																snake_case        =     model.generate(**lowerCAmelCase						,      eos_token_id=lowerCAmelCase						,      **lowerCAmelCase      )
										self.assertTrue(expectation == len(generated_tokens[0]      )      )

										snake_case        =     [6_38, 1_98]
										with tf.device(':/CPU:0'      ):
																tf.random.set_seed(0      )
																snake_case        =     model.generate(**lowerCAmelCase						,      eos_token_id=lowerCAmelCase						,      **lowerCAmelCase      )
										self.assertTrue(expectation == len(generated_tokens[0]      )      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'      )
										snake_case        =     'Hugging Face is a technology company based in New York and Paris.'
										snake_case        =     bart_tokenizer(lowerCAmelCase						,      return_tensors='tf'      ).input_ids
										snake_case        =     TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'      )
										snake_case        =     bart_model.generate(lowerCAmelCase      ).numpy()



										class 					lowerCAmelCase_      (     lowerCAmelCase   ):



														"""simple docstring"""

														def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase=None						,      **lowerCAmelCase      ):






																				"""simple docstring"""

																				return super().call(lowerCAmelCase						,      **lowerCAmelCase      )





										snake_case        =     FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart'      )
										snake_case        =     bart_model.generate(lowerCAmelCase						,      foo='bar'      ).numpy()
										self.assertTrue(np.array_equal(lowerCAmelCase						,      lowerCAmelCase      )      )



										class 					lowerCAmelCase_      (     bart_model.model.encoder.__class__   ):



														"""simple docstring"""

														def 						snake_case	(			self						,      lowerCAmelCase						,      **lowerCAmelCase      ):






																				"""simple docstring"""

																				return super().call(lowerCAmelCase						,      **lowerCAmelCase      )





										snake_case        =     FakeEncoder(bart_model.config						,      bart_model.model.shared      )
										snake_case        =     fake_encoder

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



"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


SCREAMING_SNAKE_CASE__   =					{
    "configuration_data2vec_audio": ["DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecAudioConfig"],
    "configuration_data2vec_text": [
        "DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecTextConfig",
        "Data2VecTextOnnxConfig",
    ],
    "configuration_data2vec_vision": [
        "DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecVisionConfig",
        "Data2VecVisionOnnxConfig",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__   =					[
					    "DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "Data2VecAudioForAudioFrameClassification",
					    "Data2VecAudioForCTC",
					    "Data2VecAudioForSequenceClassification",
					    "Data2VecAudioForXVector",
					    "Data2VecAudioModel",
					    "Data2VecAudioPreTrainedModel",
					]
					SCREAMING_SNAKE_CASE__   =					[
					    "DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "Data2VecTextForCausalLM",
					    "Data2VecTextForMaskedLM",
					    "Data2VecTextForMultipleChoice",
					    "Data2VecTextForQuestionAnswering",
					    "Data2VecTextForSequenceClassification",
					    "Data2VecTextForTokenClassification",
					    "Data2VecTextModel",
					    "Data2VecTextPreTrainedModel",
					]
					SCREAMING_SNAKE_CASE__   =					[
					    "DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "Data2VecVisionForImageClassification",
					    "Data2VecVisionForMaskedImageModeling",
					    "Data2VecVisionForSemanticSegmentation",
					    "Data2VecVisionModel",
					    "Data2VecVisionPreTrainedModel",
					]

if is_tf_available():
					SCREAMING_SNAKE_CASE__   =					[
					    "TFData2VecVisionForImageClassification",
					    "TFData2VecVisionForSemanticSegmentation",
					    "TFData2VecVisionModel",
					    "TFData2VecVisionPreTrainedModel",
					]

if TYPE_CHECKING:
					from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
					from .configuration_dataavec_text import (
					    DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    DataaVecTextConfig,
					    DataaVecTextOnnxConfig,
					)
					from .configuration_dataavec_vision import (
					    DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    DataaVecVisionConfig,
					    DataaVecVisionOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_dataavec_audio import (
										    DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DataaVecAudioForAudioFrameClassification,
										    DataaVecAudioForCTC,
										    DataaVecAudioForSequenceClassification,
										    DataaVecAudioForXVector,
										    DataaVecAudioModel,
										    DataaVecAudioPreTrainedModel,
										)
										from .modeling_dataavec_text import (
										    DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DataaVecTextForCausalLM,
										    DataaVecTextForMaskedLM,
										    DataaVecTextForMultipleChoice,
										    DataaVecTextForQuestionAnswering,
										    DataaVecTextForSequenceClassification,
										    DataaVecTextForTokenClassification,
										    DataaVecTextModel,
										    DataaVecTextPreTrainedModel,
										)
										from .modeling_dataavec_vision import (
										    DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DataaVecVisionForImageClassification,
										    DataaVecVisionForMaskedImageModeling,
										    DataaVecVisionForSemanticSegmentation,
										    DataaVecVisionModel,
										    DataaVecVisionPreTrainedModel,
										)
					if is_tf_available():
										from .modeling_tf_dataavec_vision import (
										    TFDataaVecVisionForImageClassification,
										    TFDataaVecVisionForSemanticSegmentation,
										    TFDataaVecVisionModel,
										    TFDataaVecVisionPreTrainedModel,
										)

else:
					import sys

					SCREAMING_SNAKE_CASE__   =					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


