"""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   ):


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      _UpperCAmelCase						 =      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						 =      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						 =      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						 =      tf_top_k_top_p_filtering(__lowerCAmelCase   ,				top_k=10   ,				top_p=0.6   ,				min_tokens_to_keep=4					)

      _UpperCAmelCase						 =      output[output != -float("""inf"""					)]
      _UpperCAmelCase						 =      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-1_2					)
      tf.debugging.assert_equal(__lowerCAmelCase   ,				__lowerCAmelCase					)



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


      class        a				(		tf.Module   ):


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



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


    @slow
    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      # TF-only test: tf.saved_model export
      _UpperCAmelCase						 =      TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""					)
      _UpperCAmelCase						 =      1
      _UpperCAmelCase						 =      2


      class        a				(		tf.Module   ):


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



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


    @slow
    @require_tensorflow_text
    def      lowerCAmelCase_  (					self	:  Optional[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=__lowerCAmelCase					)


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


            def __init__(					self	:  Dict					):
              super().__init__()
              _UpperCAmelCase						 =      text.SentencepieceTokenizer(
                  model=tf.io.gfile.GFile(os.path.join(__lowerCAmelCase   ,				"""spiece.model"""					)   ,				"""rb"""					).read()					)
              _UpperCAmelCase						 =      TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""					)


            def      lowerCAmelCase_  (					self	:  Dict   ,				__lowerCAmelCase	:  Optional[int]   ,				*__lowerCAmelCase	:  Tuple   ,				**__lowerCAmelCase	:  Union[str, Any]					):
              _UpperCAmelCase						 =      self.tokenizer.tokenize(__lowerCAmelCase					)
              _UpperCAmelCase ,				_UpperCAmelCase						 =      text.pad_model_inputs(
                  __lowerCAmelCase   ,				max_seq_length=64   ,				pad_value=self.model.config.pad_token_id					)
              _UpperCAmelCase						 =      self.model.generate(input_ids=__lowerCAmelCase   ,				attention_mask=__lowerCAmelCase					)
              return self.tokenizer.detokenize(__lowerCAmelCase					)



        _UpperCAmelCase						 =      CompleteSentenceTransformer()
        _UpperCAmelCase						 =      tf.keras.layers.Input(shape=(1,)   ,				dtype=tf.string   ,				name="""inputs"""					)
        _UpperCAmelCase						 =      complete_model(__lowerCAmelCase					)
        _UpperCAmelCase						 =      tf.keras.Model(__lowerCAmelCase   ,				__lowerCAmelCase					)
        keras_model.save(__lowerCAmelCase					)


    def      lowerCAmelCase_  (					self	:  Union[str, Any]					):
      # Has PT equivalent: this test relies on random sampling
      _UpperCAmelCase						 =      {
          """do_sample""": True,
          """num_beams""": 1,
          """top_p""": 0.7,
          """top_k""": 10,
          """temperature""": 0.7,
      }
      _UpperCAmelCase						 =      14

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

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

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


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


      class        a				(		lowerCAmelCase_   ):


          def      lowerCAmelCase_  (					self	:  Optional[int]   ,				__lowerCAmelCase	:  Tuple   ,				__lowerCAmelCase	:  Union[str, Any]=None   ,				**__lowerCAmelCase	:  Tuple					):
            return super().call(__lowerCAmelCase   ,				**__lowerCAmelCase					)



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


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


          def      lowerCAmelCase_  (					self	:  Optional[int]   ,				__lowerCAmelCase	:  str   ,				**__lowerCAmelCase	:  Optional[int]					):
            return super().call(__lowerCAmelCase   ,				**__lowerCAmelCase					)



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

      # Normal generation still works (the output will be different because the encoder weights are different)
      _UpperCAmelCase						 =      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"""


# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
UpperCAmelCase__  		=						abspath(join(dirname(dirname(__file__)), """src"""))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="""ignore""", category=FutureWarning)






def     __UpperCAmelCase					(			lowercase		):







  """simple docstring"""
  from diffusers.utils.testing_utils import pytest_addoption_shared

  pytest_addoption_shared(lowercase		)






def     __UpperCAmelCase					(			lowercase		):







  """simple docstring"""
  from diffusers.utils.testing_utils import pytest_terminal_summary_main

  _UpperCAmelCase						 =      terminalreporter.config.getoption("""--make-reports"""		)
  if make_reports:
    pytest_terminal_summary_main(lowercase   ,id=lowercase		)
