



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





     '''simple docstring'''



     def  __lowerCAmelCase	(					self		)							->					int:
         _UpperCAmelCase							:  Tuple											=    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[int]											=    tf.convert_to_tensor(
             [[0, 0], [0, 9], [0, 1_0], [0, 2_5], [0, 2_6], [1, 1_3], [1, 1_7], [1, 1_8], [1, 2_0], [1, 2_7]]       ,	dtype=tf.intaa       ,	)  # expected non filtered idx as noted above

         _UpperCAmelCase							:  Union[str, 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[Any]											=    tf_top_k_top_p_filtering(A       ,	top_k=1_0       ,	top_p=0.6       ,	min_tokens_to_keep=4		)

         _UpperCAmelCase							:  Tuple											=    output[output != -float('''inf'''		)]
         _UpperCAmelCase							:  Union[str, Any]											=    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 							_UpperCAmelCase							( unittest.TestCase		,a      ):





     '''simple docstring'''



     if is_tf_available():
          a__									={
              '''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		)							->					Union[str, Any]:
         # TF-only test: tf.saved_model export
         _UpperCAmelCase							:  List[Any]											=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''		)
         _UpperCAmelCase							:  int											=    2
         _UpperCAmelCase							:  int											=    2
         class 							_UpperCAmelCase							( tf.Module      ):





              '''simple docstring'''



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



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





     @slow
     def  __lowerCAmelCase	(					self		)							->					Any:
         # TF-only test: tf.saved_model export
         _UpperCAmelCase							:  List[Any]											=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''		)
         _UpperCAmelCase							:  str											=    1
         _UpperCAmelCase							:  List[Any]											=    2
         class 							_UpperCAmelCase							( tf.Module      ):





              '''simple docstring'''



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



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





     @slow
     @require_tensorflow_text
     def  __lowerCAmelCase	(					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=A		)
             class 							_UpperCAmelCase							( tf.keras.layers.Layer      ):





                  '''simple docstring'''



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





                  def  __lowerCAmelCase	(					self       ,	A       ,	*A       ,	**A		)							->					Any:
                      _UpperCAmelCase							:  Any											=    self.tokenizer.tokenize(A		)
                      _UpperCAmelCase							,				_UpperCAmelCase							:  List[str]											=    text.pad_model_inputs(
                          A       ,	max_seq_length=6_4       ,	pad_value=self.model.config.pad_token_id		)
                      _UpperCAmelCase							:  List[str]											=    self.model.generate(input_ids=A       ,	attention_mask=A		)
                      return self.tokenizer.detokenize(A		)



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





     def  __lowerCAmelCase	(					self		)							->					Tuple:
         # Has PT equivalent: this test relies on random sampling
         _UpperCAmelCase							:  Tuple											=    {
             '''do_sample''': True,
             '''num_beams''': 1,
             '''top_p''': 0.7,
             '''top_k''': 1_0,
             '''temperature''': 0.7,
         }
         _UpperCAmelCase							:  Optional[Any]											=    1_4

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

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

         _UpperCAmelCase							:  List[str]											=    [6_3_8, 1_9_8]
         with tf.device(''':/CPU:0'''		):
             tf.random.set_seed(0		)
             _UpperCAmelCase							:  Union[str, Any]											=    model.generate(**A       ,	eos_token_id=A       ,	**A		)
         self.assertTrue(expectation == len(generated_tokens[0]		)		)





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





              '''simple docstring'''



              def  __lowerCAmelCase	(					self       ,	A       ,	A=None       ,	**A		)							->					Optional[int]:
                  return super().call(A       ,	**A		)



         _UpperCAmelCase							:  List[str]											=    FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''		)
         _UpperCAmelCase							:  Union[str, Any]											=    bart_model.generate(A       ,	foo='''bar'''		).numpy()
         self.assertTrue(np.array_equal(A       ,	A		)		)
         class 							_UpperCAmelCase							( bart_model.model.encoder.__class__      ):





              '''simple docstring'''



              def  __lowerCAmelCase	(					self       ,	A       ,	**A		)							->					List[Any]:
                  return super().call(A       ,	**A		)



         _UpperCAmelCase							:  List[Any]											=    FakeEncoder(bart_model.config       ,	bart_model.model.shared		)
         _UpperCAmelCase							:  Optional[int]											=    fake_encoder

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







"""simple docstring"""
import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin
@skip_mps
class 							_UpperCAmelCase							( a		,a		,unittest.TestCase      ):





     '''simple docstring'''



     a__									=IFImgaImgSuperResolutionPipeline
     a__									=TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
     a__									=TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}      )
     a__									=PipelineTesterMixin.required_optional_params - {'''latents'''}





     def  __lowerCAmelCase	(					self		)							->					List[str]:
         return self._get_superresolution_dummy_components()





     def  __lowerCAmelCase	(					self       ,	A       ,	A=0		)							->					Union[str, Any]:
         if str(A		).startswith('''mps'''		):
             _UpperCAmelCase							:  Any											=    torch.manual_seed(A		)
         else:
             _UpperCAmelCase							:  int											=    torch.Generator(device=A		).manual_seed(A		)

         _UpperCAmelCase							:  str											=    floats_tensor((1, 3, 3_2, 3_2)       ,	rng=random.Random(A		)		).to(A		)
         _UpperCAmelCase							:  Dict											=    floats_tensor((1, 3, 1_6, 1_6)       ,	rng=random.Random(A		)		).to(A		)

         _UpperCAmelCase							:  List[Any]											=    {
             '''prompt''': '''A painting of a squirrel eating a burger''',
             '''image''': image,
             '''original_image''': original_image,
             '''generator''': generator,
             '''num_inference_steps''': 2,
             '''output_type''': '''numpy''',
         }

         return inputs





     @unittest.skipIf(
         torch_device != '''cuda''' or not is_xformers_available()       ,	reason='''XFormers attention is only available with CUDA and `xformers` installed'''       ,	)
     def  __lowerCAmelCase	(					self		)							->					List[Any]:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)





     def  __lowerCAmelCase	(					self		)							->					List[str]:
         self._test_save_load_optional_components()





     @unittest.skipIf(torch_device != '''cuda'''       ,	reason='''float16 requires CUDA'''		)
     def  __lowerCAmelCase	(					self		)							->					Optional[Any]:
         # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
         super().test_save_load_floataa(expected_max_diff=1E-1		)





     def  __lowerCAmelCase	(					self		)							->					int:
         self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)





     def  __lowerCAmelCase	(					self		)							->					Union[str, Any]:
         self._test_save_load_local()





     def  __lowerCAmelCase	(					self		)							->					Union[str, Any]:
         self._test_inference_batch_single_identical(
             expected_max_diff=1E-2       ,	)


