


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







     def 							lowercase__       (						self :						int      ):
           SCREAMING_SNAKE_CASE__       :  Optional[int]						     =		tf.convert_to_tensor(
               [
                   [
                       8.2220991,  # 3rd highest value; idx. 0
                       -0.5620044,
                       5.23229752,
                       4.0386393,
                       -6.8798378,
                       -0.54785802,
                       -3.2012153,
                       2.92777176,
                       1.88171953,
                       7.35341276,  # 5th highest value; idx. 9
                       8.43207833,  # 2nd highest value; idx. 10
                       -9.85711836,
                       -5.96209236,
                       -1.13039161,
                       -7.1115294,
                       -0.8369633,
                       -5.3186408,
                       7.06427407,
                       0.81369344,
                       -0.82023817,
                       -5.9179796,
                       0.58813443,
                       -6.99778438,
                       4.71551189,
                       -0.18771637,
                       7.44020759,  # 4th highest value; idx. 25
                       9.38450987,  # 1st highest value; idx. 26
                       2.12662941,
                       -9.32562038,
                       2.35652522,
                   ],  # cummulative prob of 5 highest values <= 0.6
                   [
                       0.58425518,
                       4.53139238,
                       -5.57510464,
                       -6.28030699,
                       -7.19529503,
                       -4.02122551,
                       1.39337037,
                       -6.06707057,
                       1.59480517,
                       -9.643119,
                       0.03907799,
                       0.67231762,
                       -8.88206726,
                       6.27115922,  # 4th highest value; idx. 13
                       2.28520723,
                       4.82767506,
                       4.30421368,
                       8.8275313,  # 2nd highest value; idx. 17
                       5.44029958,  # 5th highest value; idx. 18
                       -4.4735794,
                       7.38579536,  # 3rd highest value; idx. 20
                       -2.91051663,
                       2.61946077,
                       -2.5674762,
                       -9.48959302,
                       -4.02922645,
                       -1.35416918,
                       9.67702323,  # 1st highest value; idx. 27
                       -5.89478553,
                       1.85370467,
                   ],  # cummulative prob of 5 highest values <= 0.6
               ]   ,   dtype=tf.floataa   ,   )

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

           SCREAMING_SNAKE_CASE__       :  Optional[Any]						     =		tf.convert_to_tensor(
               [8.222099, 7.3534126, 8.432078, 7.4402075, 9.38451, 6.271159, 8.827531, 5.4402995, 7.3857956, 9.677023]   ,   dtype=tf.floataa   ,   )  # expected non filtered values as noted above

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

           SCREAMING_SNAKE_CASE__       :  Union[str, Any]						     =		output[output != -float('''inf'''      )]
           SCREAMING_SNAKE_CASE__       :  Dict						     =		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 							lowercase  (						unittest.TestCase    ,       _UpperCAmelCase			):
     # setting framework_dependent_parameters needs to be gated, just like its contents' imports
     if is_tf_available():
          lowerCamelCase			:			Optional[int]      = {
              '''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 :						Any      ):
           # TF-only test: tf.saved_model export
           SCREAMING_SNAKE_CASE__       :  Any						     =		TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''      )
           SCREAMING_SNAKE_CASE__       :  List[Any]						     =		2
           SCREAMING_SNAKE_CASE__       :  Dict						     =		2

           class 							lowercase  (						tf.Module			):







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




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







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

           class 							lowercase  (						tf.Module			):







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




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







     @slow
     @require_tensorflow_text
     def 							lowercase__       (						self :						Optional[int]      ):
           # 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=_lowercase      )

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







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







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




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







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

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

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

           SCREAMING_SNAKE_CASE__       :  List[str]						     =		[6_38, 1_98]
           with tf.device(''':/CPU:0'''      ):
                 tf.random.set_seed(0      )
                 SCREAMING_SNAKE_CASE__       :  Optional[Any]						     =		model.generate(**_lowercase   ,   eos_token_id=_lowercase   ,   **_lowercase      )
           self.assertTrue(expectation == len(generated_tokens[0]      )      )







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

           class 							lowercase  (						_UpperCAmelCase			):







                def 							lowercase__       (						self :						Optional[Any]   ,   _lowercase :						Optional[int]   ,   _lowercase :						List[str]=None   ,   **_lowercase :						Union[str, Any]      ):
                      return super().call(_lowercase   ,   **_lowercase      )




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

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







                def 							lowercase__       (						self :						Union[str, Any]   ,   _lowercase :						List[str]   ,   **_lowercase :						List[str]      ):
                      return super().call(_lowercase   ,   **_lowercase      )




           SCREAMING_SNAKE_CASE__       :  Dict						     =		FakeEncoder(bart_model.config   ,   bart_model.model.shared      )
           SCREAMING_SNAKE_CASE__       :  List[Any]						     =		fake_encoder

           # Normal generation still works (the output will be different because the encoder weights are different)
           SCREAMING_SNAKE_CASE__       :  Dict						     =		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 timeit import timeit


def     lowercase	(    a ):



		'''simple docstring'''




		if number < 0:
				raise ValueError("the value of input must not be negative" )
		SCREAMING_SNAKE_CASE_				:Optional[int]				     =						0
		while number:
				number &= number - 1
				result += 1
		return result


def     lowercase	(    a ):



		'''simple docstring'''




		if number < 0:
				raise ValueError("the value of input must not be negative" )
		SCREAMING_SNAKE_CASE_				:List[Any]				     =						0
		while number:
				if number % 2 == 1:
						result += 1
				number >>= 1
		return result


def     lowercase	(    ):



		'''simple docstring'''




		def do_benchmark(a ) -> None:
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						"import __main__ as z"
				print(F"Benchmark when {number = }:" )
				print(F"{get_set_bits_count_using_modulo_operator(a ) = }" )
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						timeit("z.get_set_bits_count_using_modulo_operator(25)"     , setup=a )
				print(F"timeit() runs in {timing} seconds" )
				print(F"{get_set_bits_count_using_brian_kernighans_algorithm(a ) = }" )
				SCREAMING_SNAKE_CASE_				:str				     =						timeit(
				    "z.get_set_bits_count_using_brian_kernighans_algorithm(25)"     , setup=a     , )
				print(F"timeit() runs in {timing} seconds" )

		for number in (25, 37, 58, 0):
				do_benchmark(a )
				print()


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		benchmark()






