


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

     def   UpperCAmelCase__       (     self       :   str       ):






          '''simple docstring'''






          lowercase_  							=			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_  							=			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_  							=			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_  							=			tf_top_k_top_p_filtering(UpperCamelCase__							,					top_k=10							,					top_p=0.6							,					min_tokens_to_keep=4       )

          lowercase_  							=			output[output != -float("""inf"""       )]
          lowercase_  							=			tf.cast(
              tf.where(tf.not_equal(UpperCamelCase__							,					tf.constant(-float("""inf"""       )							,					dtype=tf.floataa       )       )       )							,					dtype=tf.intaa							,					)

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







@require_tf
class        UpperCamelCase__   (	unittest.TestCase							,				__magic_name__   ):
     # setting framework_dependent_parameters needs to be gated, just like its contents' imports
     if is_tf_available():
          __SCREAMING_SNAKE_CASE       :  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   UpperCAmelCase__       (     self       :   str       ):






          '''simple docstring'''






          lowercase_  							=			TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""       )
          lowercase_  							=			2
          lowercase_  							=			2







          class        UpperCamelCase__   (	tf.Module   ):

               def __init__(     self       :   List[Any]							,					UpperCamelCase__       :   List[Any]       ):






                    '''simple docstring'''






                    super(UpperCamelCase__							,					self       ).__init__()
                    lowercase_  							=			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=UpperCamelCase__							,					)
               def   UpperCAmelCase__       (     self       :   Union[str, Any]							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   str       ):






                    '''simple docstring'''






                    lowercase_  							=			self.model.generate(
                        input_ids=UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					max_new_tokens=UpperCamelCase__							,					return_dict_in_generate=UpperCamelCase__							,					)
                    return {"sequences": outputs["sequences"]}



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

     @slow
     def   UpperCAmelCase__       (     self       :   Tuple       ):






          '''simple docstring'''






          lowercase_  							=			TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""       )
          lowercase_  							=			1
          lowercase_  							=			2







          class        UpperCamelCase__   (	tf.Module   ):

               def __init__(     self       :   Tuple							,					UpperCamelCase__       :   Any       ):






                    '''simple docstring'''






                    super(UpperCamelCase__							,					self       ).__init__()
                    lowercase_  							=			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=UpperCamelCase__							,					)
               def   UpperCAmelCase__       (     self       :   Tuple							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   Dict       ):






                    '''simple docstring'''






                    lowercase_  							=			self.model.generate(
                        input_ids=UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					max_new_tokens=UpperCamelCase__							,					return_dict_in_generate=UpperCamelCase__							,					)
                    return {"sequences": outputs["sequences"]}



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

     @slow
     @require_tensorflow_text
     def   UpperCAmelCase__       (     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=UpperCamelCase__       )







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

                    def __init__(     self       :   int       ):






                         '''simple docstring'''






                         super().__init__()
                         lowercase_  							=			text.SentencepieceTokenizer(
                             model=tf.io.gfile.GFile(os.path.join(UpperCamelCase__							,					"""spiece.model"""       )							,					"""rb"""       ).read()       )
                         lowercase_  							=			TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""       )







                    def   UpperCAmelCase__       (     self       :   Any							,					UpperCamelCase__       :   Tuple							,					*UpperCamelCase__       :   Dict							,					**UpperCamelCase__       :   Optional[int]       ):






                         '''simple docstring'''






                         lowercase_  							=			self.tokenizer.tokenize(UpperCamelCase__       )
                         lowercase_							,					lowercase_  							=			text.pad_model_inputs(
                             UpperCamelCase__							,					max_seq_length=64							,					pad_value=self.model.config.pad_token_id       )
                         lowercase_  							=			self.model.generate(input_ids=UpperCamelCase__							,					attention_mask=UpperCamelCase__       )
                         return self.tokenizer.detokenize(UpperCamelCase__       )



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

     def   UpperCAmelCase__       (     self       :   Optional[int]       ):






          '''simple docstring'''






          lowercase_  							=			{
              """do_sample""": True,
              """num_beams""": 1,
              """top_p""": 0.7,
              """top_k""": 10,
              """temperature""": 0.7,
          }
          lowercase_  							=			14

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

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

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







     def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






          '''simple docstring'''






          lowercase_  							=			AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""       )
          lowercase_  							=			"""Hugging Face is a technology company based in New York and Paris."""
          lowercase_  							=			bart_tokenizer(UpperCamelCase__							,					return_tensors="""tf"""       ).input_ids
          lowercase_  							=			TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""       )
          lowercase_  							=			bart_model.generate(UpperCamelCase__       ).numpy()







          class        UpperCamelCase__   (	__magic_name__   ):

               def   UpperCAmelCase__       (     self       :   List[str]							,					UpperCamelCase__       :   Dict							,					UpperCamelCase__       :   Tuple=None							,					**UpperCamelCase__       :   Dict       ):






                    '''simple docstring'''






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



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







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

               def   UpperCAmelCase__       (     self       :   Any							,					UpperCamelCase__       :   List[Any]							,					**UpperCamelCase__       :   int       ):






                    '''simple docstring'''






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



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

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






from __future__ import annotations

import sys
from collections import deque
from typing import Generic, TypeVar

a					  =     TypeVar('T')







class        UpperCamelCase__   (	Generic[T]   ):
					__SCREAMING_SNAKE_CASE       :  deque[T]  # Cache store of keys
					__SCREAMING_SNAKE_CASE       :  set[T]  # References of the keys in cache
					__SCREAMING_SNAKE_CASE       :  int						=   10  # Maximum capacity of cache

					def __init__(     self       :   str							,					UpperCamelCase__       :   int       ):






										'''simple docstring'''






										lowercase_  							=			deque()
										lowercase_  							=			set()
										if not n:
															lowercase_  							=			sys.maxsize
										elif n < 0:
															raise ValueError("""n should be an integer greater than 0."""       )
										else:
															lowercase_  							=			n

					def   UpperCAmelCase__       (     self       :   Optional[int]							,					UpperCamelCase__       :   T       ):






										'''simple docstring'''






										if x not in self.key_reference:
															if len(self.dq_store       ) == LRUCache._MAX_CAPACITY:
																				lowercase_  							=			self.dq_store.pop()
																				self.key_reference.remove(UpperCamelCase__       )
										else:
															self.dq_store.remove(UpperCamelCase__       )

										self.dq_store.appendleft(UpperCamelCase__       )
										self.key_reference.add(UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										for k in self.dq_store:
															print(UpperCamelCase__       )







					def __repr__(     self       :   Optional[Any]       ):






										'''simple docstring'''






										return F'''LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store       )}'''


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							a					  =     LRUCache(4)
							lru_cache.refer('A')
							lru_cache.refer(2)
							lru_cache.refer(3)
							lru_cache.refer('A')
							lru_cache.refer(4)
							lru_cache.refer(5)
							lru_cache.display()

							print(lru_cache)
							assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"


