
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 						lowercase__  (						unittest.TestCase  ):
	def      A_				(			self							:   str							):
						SCREAMING_SNAKE_CASE__													= tf.convert_to_tensor(
						    [
						        [
						            8.2_220_991,  # 3rd highest value; idx. 0
						            -0.5_620_044,
						            5.23_229_752,
						            4.0_386_393,
						            -6.8_798_378,
						            -0.54_785_802,
						            -3.2_012_153,
						            2.92_777_176,
						            1.88_171_953,
						            7.35_341_276,  # 5th highest value; idx. 9
						            8.43_207_833,  # 2nd highest value; idx. 10
						            -9.85_711_836,
						            -5.96_209_236,
						            -1.13_039_161,
						            -7.1_115_294,
						            -0.8_369_633,
						            -5.3_186_408,
						            7.06_427_407,
						            0.81_369_344,
						            -0.82_023_817,
						            -5.9_179_796,
						            0.58_813_443,
						            -6.99_778_438,
						            4.71_551_189,
						            -0.18_771_637,
						            7.44_020_759,  # 4th highest value; idx. 25
						            9.38_450_987,  # 1st highest value; idx. 26
						            2.12_662_941,
						            -9.32_562_038,
						            2.35_652_522,
						        ],  # cummulative prob of 5 highest values <= 0.6
						        [
						            0.58_425_518,
						            4.53_139_238,
						            -5.57_510_464,
						            -6.28_030_699,
						            -7.19_529_503,
						            -4.02_122_551,
						            1.39_337_037,
						            -6.06_707_057,
						            1.59_480_517,
						            -9.643_119,
						            0.03_907_799,
						            0.67_231_762,
						            -8.88_206_726,
						            6.27_115_922,  # 4th highest value; idx. 13
						            2.28_520_723,
						            4.82_767_506,
						            4.30_421_368,
						            8.8_275_313,  # 2nd highest value; idx. 17
						            5.44_029_958,  # 5th highest value; idx. 18
						            -4.4_735_794,
						            7.38_579_536,  # 3rd highest value; idx. 20
						            -2.91_051_663,
						            2.61_946_077,
						            -2.5_674_762,
						            -9.48_959_302,
						            -4.02_922_645,
						            -1.35_416_918,
						            9.67_702_323,  # 1st highest value; idx. 27
						            -5.89_478_553,
						            1.85_370_467,
						        ],  # cummulative prob of 5 highest values <= 0.6
						    ]       ,   dtype=tf.floataa       ,   )

						SCREAMING_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

						SCREAMING_SNAKE_CASE__													= tf.convert_to_tensor(
						    [8.222_099, 7.3_534_126, 8.432_078, 7.4_402_075, 9.38_451, 6.271_159, 8.827_531, 5.4_402_995, 7.3_857_956, 9.677_023]       ,   dtype=tf.floataa       ,   )  # expected non filtered values as noted above

						SCREAMING_SNAKE_CASE__													= tf_top_k_top_p_filtering(UpperCAmelCase_       ,   top_k=10       ,   top_p=0.6       ,   min_tokens_to_keep=4							)

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

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





@require_tf
class 						lowercase__  (						unittest.TestCase     ,       _UpperCAmelCase  ):
	# setting framework_dependent_parameters needs to be gated, just like its contents' imports
	if is_tf_available():
		A__    :   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      A_				(			self							:   List[str]							):
						# TF-only test: tf.saved_model export
						SCREAMING_SNAKE_CASE__													= TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'							)
						SCREAMING_SNAKE_CASE__													= 2
						SCREAMING_SNAKE_CASE__													= 2




						class 						lowercase__  (						tf.Module  ):
							def __init__(			self							:   Dict       ,   UpperCAmelCase_							:   Tuple							):
												super(UpperCAmelCase_       ,   self							).__init__()
												SCREAMING_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=UpperCAmelCase_       ,   )
							def      A_				(			self							:   Optional[int]       ,   UpperCAmelCase_							:   Tuple       ,   UpperCAmelCase_							:   Optional[Any]							):
												SCREAMING_SNAKE_CASE__													= self.model.generate(
												    input_ids=UpperCAmelCase_       ,   attention_mask=UpperCAmelCase_       ,   max_new_tokens=UpperCAmelCase_       ,   return_dict_in_generate=UpperCAmelCase_       ,   )
												return {"sequences": outputs["sequences"]}





						SCREAMING_SNAKE_CASE__													= [[2, 0], [102, 103]]
						SCREAMING_SNAKE_CASE__													= [[1, 0], [1, 1]]
						SCREAMING_SNAKE_CASE__													= DummyModel(model=UpperCAmelCase_							)
						with tempfile.TemporaryDirectory() as tmp_dir:
											tf.saved_model.save(UpperCAmelCase_       ,   UpperCAmelCase_       ,   signatures={'serving_default': dummy_model.serving}							)
											SCREAMING_SNAKE_CASE__													= tf.saved_model.load(UpperCAmelCase_							).signatures['serving_default']
											for batch_size in range(1       ,   len(UpperCAmelCase_							) + 1							):
																SCREAMING_SNAKE_CASE__													= {
																    'input_ids': tf.constant(dummy_input_ids[:batch_size]							),
																    'attention_mask': tf.constant(dummy_attention_masks[:batch_size]							),
																}
																SCREAMING_SNAKE_CASE__													= serving_func(**UpperCAmelCase_							)['sequences']
																SCREAMING_SNAKE_CASE__													= test_model.generate(**UpperCAmelCase_       ,   max_new_tokens=UpperCAmelCase_							)
																tf.debugging.assert_equal(UpperCAmelCase_       ,   UpperCAmelCase_							)
	@slow
	def      A_				(			self							:   List[Any]							):
						# TF-only test: tf.saved_model export
						SCREAMING_SNAKE_CASE__													= TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'							)
						SCREAMING_SNAKE_CASE__													= 1
						SCREAMING_SNAKE_CASE__													= 2




						class 						lowercase__  (						tf.Module  ):
							def __init__(			self							:   Tuple       ,   UpperCAmelCase_							:   str							):
												super(UpperCAmelCase_       ,   self							).__init__()
												SCREAMING_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=UpperCAmelCase_       ,   )
							def      A_				(			self							:   List[Any]       ,   UpperCAmelCase_							:   Any       ,   UpperCAmelCase_							:   List[Any]							):
												SCREAMING_SNAKE_CASE__													= self.model.generate(
												    input_ids=UpperCAmelCase_       ,   attention_mask=UpperCAmelCase_       ,   max_new_tokens=UpperCAmelCase_       ,   return_dict_in_generate=UpperCAmelCase_       ,   )
												return {"sequences": outputs["sequences"]}





						SCREAMING_SNAKE_CASE__													= [[2], [102, 103]]
						SCREAMING_SNAKE_CASE__													= [[1], [1, 1]]
						SCREAMING_SNAKE_CASE__													= DummyModel(model=UpperCAmelCase_							)
						with tempfile.TemporaryDirectory() as tmp_dir:
											tf.saved_model.save(UpperCAmelCase_       ,   UpperCAmelCase_       ,   signatures={'serving_default': dummy_model.serving}							)
											SCREAMING_SNAKE_CASE__													= tf.saved_model.load(UpperCAmelCase_							).signatures['serving_default']
											for input_row in range(len(UpperCAmelCase_							)							):
																SCREAMING_SNAKE_CASE__													= {
																    'input_ids': tf.constant([dummy_input_ids[input_row]]							),
																    'attention_mask': tf.constant([dummy_attention_masks[input_row]]							),
																}
																SCREAMING_SNAKE_CASE__													= serving_func(**UpperCAmelCase_							)['sequences']
																SCREAMING_SNAKE_CASE__													= test_model.generate(**UpperCAmelCase_       ,   max_new_tokens=UpperCAmelCase_							)
																tf.debugging.assert_equal(UpperCAmelCase_       ,   UpperCAmelCase_							)
	@slow
	@require_tensorflow_text
	def      A_				(			self							:   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=UpperCAmelCase_							)




											class 						lowercase__  (						tf.keras.layers.Layer  ):
												def __init__(			self							:   Tuple							):
																	super().__init__()
																	SCREAMING_SNAKE_CASE__													= text.SentencepieceTokenizer(
																	    model=tf.io.gfile.GFile(os.path.join(UpperCAmelCase_       ,   'spiece.model'							)       ,   'rb'							).read()							)
																	SCREAMING_SNAKE_CASE__													= TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'							)





												def      A_				(			self							:   int       ,   UpperCAmelCase_							:   Tuple       ,   *UpperCAmelCase_							:   Tuple       ,   **UpperCAmelCase_							:   List[str]							):
																	SCREAMING_SNAKE_CASE__													= self.tokenizer.tokenize(UpperCAmelCase_							)
																	SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= text.pad_model_inputs(
																	    UpperCAmelCase_       ,   max_seq_length=64       ,   pad_value=self.model.config.pad_token_id							)
																	SCREAMING_SNAKE_CASE__													= self.model.generate(input_ids=UpperCAmelCase_       ,   attention_mask=UpperCAmelCase_							)
																	return self.tokenizer.detokenize(UpperCAmelCase_							)





											SCREAMING_SNAKE_CASE__													= CompleteSentenceTransformer()
											SCREAMING_SNAKE_CASE__													= tf.keras.layers.Input(shape=(1,)       ,   dtype=tf.string       ,   name='inputs'							)
											SCREAMING_SNAKE_CASE__													= complete_model(UpperCAmelCase_							)
											SCREAMING_SNAKE_CASE__													= tf.keras.Model(UpperCAmelCase_       ,   UpperCAmelCase_							)
											keras_model.save(UpperCAmelCase_							)
	def      A_				(			self							:   Optional[int]							):
						# Has PT equivalent: this test relies on random sampling
						SCREAMING_SNAKE_CASE__													= {
						    'do_sample': True,
						    'num_beams': 1,
						    'top_p': 0.7,
						    'top_k': 10,
						    'temperature': 0.7,
						}
						SCREAMING_SNAKE_CASE__													= 14

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

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

						SCREAMING_SNAKE_CASE__													= [638, 198]
						with tf.device(':/CPU:0'							):
											tf.random.set_seed(0							)
											SCREAMING_SNAKE_CASE__													= model.generate(**UpperCAmelCase_       ,   eos_token_id=UpperCAmelCase_       ,   **UpperCAmelCase_							)
						self.assertTrue(expectation == len(generated_tokens[0]							)							)





	def      A_				(			self							:   Dict							):
						# Has PT equivalent: ample use of framework-specific code
						SCREAMING_SNAKE_CASE__													= AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'							)
						SCREAMING_SNAKE_CASE__													= 'Hugging Face is a technology company based in New York and Paris.'
						SCREAMING_SNAKE_CASE__													= bart_tokenizer(UpperCAmelCase_       ,   return_tensors='tf'							).input_ids
						SCREAMING_SNAKE_CASE__													= TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'							)
						SCREAMING_SNAKE_CASE__													= bart_model.generate(UpperCAmelCase_							).numpy()




						class 						lowercase__  (						_UpperCAmelCase  ):
							def      A_				(			self							:   List[str]       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   Any=None       ,   **UpperCAmelCase_							:   List[Any]							):
												return super().call(UpperCAmelCase_       ,   **UpperCAmelCase_							)





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




						class 						lowercase__  (						bart_model.model.encoder.__class__  ):
							def      A_				(			self							:   Any       ,   UpperCAmelCase_							:   Any       ,   **UpperCAmelCase_							:   List[Any]							):
												return super().call(UpperCAmelCase_       ,   **UpperCAmelCase_							)





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

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







from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__snake_case								=  logging.get_logger(__name__)




class 						lowercase__  (						_UpperCAmelCase  ):
	A__    :   List[str]				       =["""pixel_values"""]
	def __init__(			self							:   Dict       ,   UpperCAmelCase_							:   bool = True       ,   UpperCAmelCase_							:   int = 32       ,   UpperCAmelCase_							:   int=PILImageResampling.BILINEAR       ,   UpperCAmelCase_							:   bool = True       ,   **UpperCAmelCase_							:   Any       ,   ):
						SCREAMING_SNAKE_CASE__													= do_resize
						SCREAMING_SNAKE_CASE__													= do_rescale
						SCREAMING_SNAKE_CASE__													= size_divisor
						SCREAMING_SNAKE_CASE__													= resample
						super().__init__(**UpperCAmelCase_							)
	def      A_				(			self							:   Optional[int]       ,   UpperCAmelCase_							:   np.ndarray       ,   UpperCAmelCase_							:   int       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   Optional[ChannelDimension] = None       ,   **UpperCAmelCase_							:   Dict							):
						SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= get_image_size(UpperCAmelCase_							)
						# Rounds the height and width down to the closest multiple of size_divisor
						SCREAMING_SNAKE_CASE__													= height // size_divisor * size_divisor
						SCREAMING_SNAKE_CASE__													= width // size_divisor * size_divisor
						SCREAMING_SNAKE_CASE__													= resize(UpperCAmelCase_       ,   (new_h, new_w)       ,   resample=UpperCAmelCase_       ,   data_format=UpperCAmelCase_       ,   **UpperCAmelCase_							)
						return image
	def      A_				(			self							:   Any       ,   UpperCAmelCase_							:   np.ndarray       ,   UpperCAmelCase_							:   float       ,   UpperCAmelCase_							:   Optional[ChannelDimension] = None       ,   **UpperCAmelCase_							:   List[str]							):
						return rescale(image=UpperCAmelCase_       ,   scale=UpperCAmelCase_       ,   data_format=UpperCAmelCase_       ,   **UpperCAmelCase_							)





	def      A_				(			self							:   Dict       ,   UpperCAmelCase_							:   Union["PIL.Image.Image", TensorType, List["PIL.Image.Image"], List[TensorType]]       ,   UpperCAmelCase_							:   Optional[bool] = None       ,   UpperCAmelCase_							:   Optional[int] = None       ,   UpperCAmelCase_							:   List[str]=None       ,   UpperCAmelCase_							:   Optional[bool] = None       ,   UpperCAmelCase_							:   Optional[Union[TensorType, str]] = None       ,   UpperCAmelCase_							:   ChannelDimension = ChannelDimension.FIRST       ,   **UpperCAmelCase_							:   List[Any]       ,   ):
						SCREAMING_SNAKE_CASE__													= do_resize if do_resize is not None else self.do_resize
						SCREAMING_SNAKE_CASE__													= do_rescale if do_rescale is not None else self.do_rescale
						SCREAMING_SNAKE_CASE__													= size_divisor if size_divisor is not None else self.size_divisor
						SCREAMING_SNAKE_CASE__													= resample if resample is not None else self.resample

						if do_resize and size_divisor is None:
											raise ValueError('size_divisor is required for resizing'							)

						SCREAMING_SNAKE_CASE__													= make_list_of_images(UpperCAmelCase_							)

						if not valid_images(UpperCAmelCase_							):
											raise ValueError('Invalid image(s)'							)

						# All transformations expect numpy arrays.
						SCREAMING_SNAKE_CASE__													= [to_numpy_array(UpperCAmelCase_							) for img in images]

						if do_resize:
											SCREAMING_SNAKE_CASE__													= [self.resize(UpperCAmelCase_       ,   size_divisor=UpperCAmelCase_       ,   resample=UpperCAmelCase_							) for image in images]

						if do_rescale:
											SCREAMING_SNAKE_CASE__													= [self.rescale(UpperCAmelCase_       ,   scale=1 / 255							) for image in images]

						SCREAMING_SNAKE_CASE__													= [to_channel_dimension_format(UpperCAmelCase_       ,   UpperCAmelCase_							) for image in images]

						SCREAMING_SNAKE_CASE__													= {'pixel_values': images}
						return BatchFeature(data=UpperCAmelCase_       ,   tensor_type=UpperCAmelCase_							)





