


'''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 			a       (	unittest.TestCase ):


     """simple docstring"""






     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							Optional[int]:
          __UpperCAmelCase			:				Dict													=    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							,				)

          __UpperCAmelCase			:				Optional[Any]													=    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

          __UpperCAmelCase			:				Optional[Any]													=    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

          __UpperCAmelCase			:				Optional[int]													=    tf_top_k_top_p_filtering(snake_case							,				top_k=10							,				top_p=0.6							,				min_tokens_to_keep=4    )

          __UpperCAmelCase			:				List[str]													=    output[output != -float('''inf'''    )]
          __UpperCAmelCase			:				Union[str, Any]													=    tf.cast(
              tf.where(tf.not_equal(snake_case							,				tf.constant(-float('''inf'''    )							,				dtype=tf.floataa    )    )    )							,				dtype=tf.intaa							,				)

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



@require_tf
class 			a       (	unittest.TestCase			,						_a ):


     """simple docstring"""






     if is_tf_available():
          SCREAMING_SNAKE_CASE :				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 				lowerCamelCase__				(       self  :	Dict    )		->							List[Any]:
          # TF-only test: tf.saved_model export
          __UpperCAmelCase			:				Optional[Any]													=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''    )
          __UpperCAmelCase			:				Optional[Any]													=    2
          __UpperCAmelCase			:				Union[str, Any]													=    2



          class 			a       (	tf.Module ):


               """simple docstring"""






               def __init__(       self  :	Tuple							,				snake_case  :	List[Any]    )		->							List[str]:
                    super(snake_case							,				self    ).__init__()
                    __UpperCAmelCase			:				int													=    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=snake_case							,				)
               def 				lowerCamelCase__				(       self  :	Optional[int]							,				snake_case  :	Dict							,				snake_case  :	List[Any]    )		->							str:
                    __UpperCAmelCase			:				Dict													=    self.model.generate(
                        input_ids=snake_case							,				attention_mask=snake_case							,				max_new_tokens=snake_case							,				return_dict_in_generate=snake_case							,				)
                    return {"sequences": outputs["sequences"]}



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

     @slow
     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							List[Any]:
          # TF-only test: tf.saved_model export
          __UpperCAmelCase			:				Dict													=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''    )
          __UpperCAmelCase			:				Optional[Any]													=    1
          __UpperCAmelCase			:				Optional[int]													=    2



          class 			a       (	tf.Module ):


               """simple docstring"""






               def __init__(       self  :	Dict							,				snake_case  :	Optional[Any]    )		->							int:
                    super(snake_case							,				self    ).__init__()
                    __UpperCAmelCase			:				List[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=snake_case							,				)
               def 				lowerCamelCase__				(       self  :	Union[str, Any]							,				snake_case  :	Tuple							,				snake_case  :	List[str]    )		->							Any:
                    __UpperCAmelCase			:				Dict													=    self.model.generate(
                        input_ids=snake_case							,				attention_mask=snake_case							,				max_new_tokens=snake_case							,				return_dict_in_generate=snake_case							,				)
                    return {"sequences": outputs["sequences"]}



          __UpperCAmelCase			:				int													=    [[2], [102, 103]]
          __UpperCAmelCase			:				List[str]													=    [[1], [1, 1]]
          __UpperCAmelCase			:				int													=    DummyModel(model=snake_case    )
          with tempfile.TemporaryDirectory() as tmp_dir:
               tf.saved_model.save(snake_case							,				snake_case							,				signatures={'''serving_default''': dummy_model.serving}    )
               __UpperCAmelCase			:				Optional[Any]													=    tf.saved_model.load(snake_case    ).signatures['''serving_default''']
               for input_row in range(len(snake_case    )    ):
                    __UpperCAmelCase			:				Tuple													=    {
                        '''input_ids''': tf.constant([dummy_input_ids[input_row]]    ),
                        '''attention_mask''': tf.constant([dummy_attention_masks[input_row]]    ),
                    }
                    __UpperCAmelCase			:				List[Any]													=    serving_func(**snake_case    )['''sequences''']
                    __UpperCAmelCase			:				Optional[Any]													=    test_model.generate(**snake_case							,				max_new_tokens=snake_case    )
                    tf.debugging.assert_equal(snake_case							,				snake_case    )

     @slow
     @require_tensorflow_text
     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							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=snake_case    )



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


                    """simple docstring"""






                    def __init__(       self  :	str    )		->							Optional[int]:
                         super().__init__()
                         __UpperCAmelCase			:				List[str]													=    text.SentencepieceTokenizer(
                             model=tf.io.gfile.GFile(os.path.join(snake_case							,				'''spiece.model'''    )							,				'''rb'''    ).read()    )
                         __UpperCAmelCase			:				Tuple													=    TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5'''    )






                    def 				lowerCamelCase__				(       self  :	Tuple							,				snake_case  :	Union[str, Any]							,				*snake_case  :	Any							,				**snake_case  :	Any    )		->							Tuple:
                         __UpperCAmelCase			:				List[str]													=    self.tokenizer.tokenize(snake_case    )
                         __UpperCAmelCase							,     __UpperCAmelCase			:				int													=    text.pad_model_inputs(
                             snake_case							,				max_seq_length=64							,				pad_value=self.model.config.pad_token_id    )
                         __UpperCAmelCase			:				Any													=    self.model.generate(input_ids=snake_case							,				attention_mask=snake_case    )
                         return self.tokenizer.detokenize(snake_case    )



               __UpperCAmelCase			:				str													=    CompleteSentenceTransformer()
               __UpperCAmelCase			:				List[Any]													=    tf.keras.layers.Input(shape=(1,)							,				dtype=tf.string							,				name='''inputs'''    )
               __UpperCAmelCase			:				Union[str, Any]													=    complete_model(snake_case    )
               __UpperCAmelCase			:				List[str]													=    tf.keras.Model(snake_case							,				snake_case    )
               keras_model.save(snake_case    )

     def 				lowerCamelCase__				(       self  :	int    )		->							int:
          # Has PT equivalent: this test relies on random sampling
          __UpperCAmelCase			:				Tuple													=    {
              '''do_sample''': True,
              '''num_beams''': 1,
              '''top_p''': 0.7,
              '''top_k''': 10,
              '''temperature''': 0.7,
          }
          __UpperCAmelCase			:				List[str]													=    14

          __UpperCAmelCase			:				str													=    AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''    )
          __UpperCAmelCase			:				Optional[int]													=    '''Hello, my dog is cute and'''
          __UpperCAmelCase			:				List[str]													=    tokenizer(snake_case							,				return_tensors='''tf'''    )
          __UpperCAmelCase			:				Dict													=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''    )

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

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






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



          class 			a       (	_a ):


               """simple docstring"""






               def 				lowerCamelCase__				(       self  :	Any							,				snake_case  :	Dict							,				snake_case  :	List[str]=None							,				**snake_case  :	Union[str, Any]    )		->							Union[str, Any]:
                    return super().call(snake_case							,				**snake_case    )



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



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


               """simple docstring"""






               def 				lowerCamelCase__				(       self  :	List[str]							,				snake_case  :	Optional[Any]							,				**snake_case  :	List[Any]    )		->							Any:
                    return super().call(snake_case							,				**snake_case    )



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

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



'''simple docstring'''



from __future__ import annotations




def 			_a			(		_lowercase      :			list						):





     '''simple docstring'''






     if not nums:
          raise ValueError('''List is empty'''						)
     return sum(_lowercase						) / len(_lowercase						)


if __name__ == "__main__":
      import doctest

      doctest.testmod()