





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 							__lowercase		( self)      ->						Any:







          '''simple docstring'''

          a__						:     Tuple			=    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 ,  )

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

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

          a__						:     Tuple			=    tf_top_k_top_p_filtering(lowercase ,  top_k=10 ,  top_p=0.6 ,  min_tokens_to_keep=4)

          a__						:     Tuple			=    output[output != -float('inf')]
          a__						:     int			=    tf.cast(
              tf.where(tf.not_equal(lowercase ,  tf.constant(-float('inf') ,  dtype=tf.floataa))) ,  dtype=tf.intaa ,  )

          tf.debugging.assert_near(lowercase ,  lowercase ,  rtol=1e-12)
          tf.debugging.assert_equal(lowercase ,  lowercase)





@require_tf
class 			A__   (							unittest.TestCase			,  __UpperCAmelCase     ):




   """simple docstring"""



   if is_tf_available():
      __A       :    Dict	  =  {
          '''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 							__lowercase		( self)      ->						Dict:







          '''simple docstring'''

          a__						:     Optional[Any]			=    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2')
          a__						:     int			=    2
          a__						:     List[Any]			=    2





          class 			A__   (							tf.Module     ):




             """simple docstring"""



             def __init__( self ,  lowercase)      ->						Tuple:







                    '''simple docstring'''

                    super(lowercase ,  self).__init__()
                    a__						:     List[Any]			=    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=lowercase ,  )
             def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Optional[int]:







                    '''simple docstring'''

                    a__						:     List[str]			=    self.model.generate(
                        input_ids=lowercase ,  attention_mask=lowercase ,  max_new_tokens=lowercase ,  return_dict_in_generate=lowercase ,  )
                    return {"sequences": outputs["sequences"]}

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

   @slow
   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     List[Any]			=    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2')
          a__						:     Tuple			=    1
          a__						:     List[str]			=    2





          class 			A__   (							tf.Module     ):




             """simple docstring"""



             def __init__( self ,  lowercase)      ->						int:







                    '''simple docstring'''

                    super(lowercase ,  self).__init__()
                    a__						:     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=lowercase ,  )
             def 							__lowercase		( self ,  lowercase ,  lowercase)      ->						Dict:







                    '''simple docstring'''

                    a__						:     Union[str, Any]			=    self.model.generate(
                        input_ids=lowercase ,  attention_mask=lowercase ,  max_new_tokens=lowercase ,  return_dict_in_generate=lowercase ,  )
                    return {"sequences": outputs["sequences"]}

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

   @slow
   @require_tensorflow_text
   def 							__lowercase		( self)      ->						Optional[int]:







          '''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=lowercase)





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




                    """simple docstring"""



                    def __init__( self)      ->						Optional[int]:







                           '''simple docstring'''

                           super().__init__()
                           a__						:     Union[str, Any]			=    text.SentencepieceTokenizer(
                               model=tf.io.gfile.GFile(os.path.join(lowercase ,  'spiece.model') ,  'rb').read())
                           a__						:     Optional[Any]			=    TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5')

                    def 							__lowercase		( self ,  lowercase ,  *lowercase ,  **lowercase)      ->						Union[str, Any]:







                           '''simple docstring'''

                           a__						:     Union[str, Any]			=    self.tokenizer.tokenize(lowercase)
                           a__			,							a__						:     Optional[Any]			=    text.pad_model_inputs(
                               lowercase ,  max_seq_length=64 ,  pad_value=self.model.config.pad_token_id)
                           a__						:     Optional[int]			=    self.model.generate(input_ids=lowercase ,  attention_mask=lowercase)
                           return self.tokenizer.detokenize(lowercase)

                 a__						:     str			=    CompleteSentenceTransformer()
                 a__						:     Any			=    tf.keras.layers.Input(shape=(1,) ,  dtype=tf.string ,  name='inputs')
                 a__						:     Optional[Any]			=    complete_model(lowercase)
                 a__						:     Optional[Any]			=    tf.keras.Model(lowercase ,  lowercase)
                 keras_model.save(lowercase)

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     Tuple			=    {
              'do_sample': True,
              'num_beams': 1,
              'top_p': 0.7,
              'top_k': 10,
              'temperature': 0.7,
          }
          a__						:     Optional[Any]			=    14

          a__						:     Dict			=    AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2')
          a__						:     Union[str, Any]			=    'Hello, my dog is cute and'
          a__						:     str			=    tokenizer(lowercase ,  return_tensors='tf')
          a__						:     Tuple			=    TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2')

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

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

   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Dict			=    AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart')
          a__						:     Any			=    'Hugging Face is a technology company based in New York and Paris.'
          a__						:     str			=    bart_tokenizer(lowercase ,  return_tensors='tf').input_ids
          a__						:     Optional[int]			=    TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart')
          a__						:     Union[str, Any]			=    bart_model.generate(lowercase).numpy()





          class 			A__   (							__UpperCAmelCase     ):




             """simple docstring"""



             def 							__lowercase		( self ,  lowercase ,  lowercase=None ,  **lowercase)      ->						List[str]:







                    '''simple docstring'''

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

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





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




             """simple docstring"""



             def 							__lowercase		( self ,  lowercase ,  **lowercase)      ->						Any:







                    '''simple docstring'''

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

          a__						:     str			=    FakeEncoder(bart_model.config ,  bart_model.model.shared)
          a__						:     int			=    fake_encoder

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









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


lowercase				:	str      						=  {
    """configuration_vision_encoder_decoder""": ["""VisionEncoderDecoderConfig""", """VisionEncoderDecoderOnnxConfig"""]
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Optional[Any]      						=  ["""VisionEncoderDecoderModel"""]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	Optional[int]      						=  ["""TFVisionEncoderDecoderModel"""]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowercase				:	List[str]      						=  ["""FlaxVisionEncoderDecoderModel"""]

if TYPE_CHECKING:
    from .configuration_vision_encoder_decoder import VisionEncoderDecoderConfig, VisionEncoderDecoderOnnxConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_vision_encoder_decoder import VisionEncoderDecoderModel

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_vision_encoder_decoder import TFVisionEncoderDecoderModel

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_vision_encoder_decoder import FlaxVisionEncoderDecoderModel

else:
    import sys

    lowercase				:	Optional[int]      						=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


