

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





    def       snake_case_				(      self):
         lowercase__    :   List[Any]      =       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						,   )

         lowercase__    :   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

         lowercase__    :   int      =       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

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

         lowercase__    :   Any      =       output[output != -float('inf')]
         lowercase__    :   int      =       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-12)
         tf.debugging.assert_equal(a						,   a)



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


         class       SCREAMING_SNAKE_CASE__					(tf.Module     ):





             def __init__(      self						,   a):
                  super(a						,   self).__init__()
                  lowercase__    :   Dict      =       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       snake_case_				(      self						,   a						,   a):
                  lowercase__    :   Tuple      =       self.model.generate(
                      input_ids=a						,   attention_mask=a						,   max_new_tokens=a						,   return_dict_in_generate=a						,   )
                  return {"sequences": outputs["sequences"]}



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





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


         class       SCREAMING_SNAKE_CASE__					(tf.Module     ):





             def __init__(      self						,   a):
                  super(a						,   self).__init__()
                  lowercase__    :   Optional[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       snake_case_				(      self						,   a						,   a):
                  lowercase__    :   Union[str, Any]      =       self.model.generate(
                      input_ids=a						,   attention_mask=a						,   max_new_tokens=a						,   return_dict_in_generate=a						,   )
                  return {"sequences": outputs["sequences"]}



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





    @slow
    @require_tensorflow_text
    def       snake_case_				(      self):
         # 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       SCREAMING_SNAKE_CASE__					(tf.keras.layers.Layer     ):





                  def __init__(      self):
                       super().__init__()
                       lowercase__    :   List[Any]      =       text.SentencepieceTokenizer(
                           model=tf.io.gfile.GFile(os.path.join(a						,   'spiece.model')						,   'rb').read())
                       lowercase__    :   Any      =       TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5')





                  def       snake_case_				(      self						,   a						,   *a						,   **a):
                       lowercase__    :   Union[str, Any]      =       self.tokenizer.tokenize(a)
                       lowercase__      , lowercase__    :   Tuple      =       text.pad_model_inputs(
                           a						,   max_seq_length=64						,   pad_value=self.model.config.pad_token_id)
                       lowercase__    :   Union[str, Any]      =       self.model.generate(input_ids=a						,   attention_mask=a)
                       return self.tokenizer.detokenize(a)



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





    def       snake_case_				(      self):
         # Has PT equivalent: this test relies on random sampling
         lowercase__    :   Tuple      =       {
             'do_sample': True,
             'num_beams': 1,
             'top_p': 0.7,
             'top_k': 10,
             'temperature': 0.7,
         }
         lowercase__    :   Dict      =       14

         lowercase__    :   int      =       AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2')
         lowercase__    :   Optional[int]      =       'Hello, my dog is cute and'
         lowercase__    :   int      =       tokenizer(a						,   return_tensors='tf')
         lowercase__    :   Any      =       TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2')

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

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





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


         class       SCREAMING_SNAKE_CASE__					(__snake_case     ):





             def       snake_case_				(      self						,   a						,   a=None						,   **a):
                  return super().call(a						,   **a)



         lowercase__    :   Union[str, Any]      =       FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart')
         lowercase__    :   Any      =       bart_model.generate(a						,   foo='bar').numpy()
         self.assertTrue(np.array_equal(a						,   a))


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





             def       snake_case_				(      self						,   a						,   **a):
                  return super().call(a						,   **a)



         lowercase__    :   Union[str, Any]      =       FakeEncoder(bart_model.config						,   bart_model.model.shared)
         lowercase__    :   Optional[int]      =       fake_encoder

         # Normal generation still works (the output will be different because the encoder weights are different)
         lowercase__    :   Union[str, 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 DonutProcessor


snake_case_			  = '''naver-clova-ix/donut-base'''


class       SCREAMING_SNAKE_CASE__					(unittest.TestCase     ):





    def       snake_case_				(      self):
         lowercase__    :   Dict      =       DonutProcessor.from_pretrained(a)





    def       snake_case_				(      self):
         lowercase__    :   Tuple      =       {
             'name': 'John Doe',
             'age': '99',
             'city': 'Atlanta',
             'state': 'GA',
             'zip': '30301',
             'phone': '123-4567',
             'nicknames': [{'nickname': 'Johnny'}, {'nickname': 'JD'}],
         }

         lowercase__    :   Tuple      =       (
             '<s_name>John Doe</s_name><s_age>99</s_age><s_city>Atlanta</s_city>'
             '<s_state>GA</s_state><s_zip>30301</s_zip><s_phone>123-4567</s_phone>'
             '<s_nicknames><s_nickname>Johnny</s_nickname>'
             '<sep/><s_nickname>JD</s_nickname></s_nicknames>'
         )
         lowercase__    :   str      =       self.processor.tokenajson(a)

         self.assertDictEqual(a						,   a)

