


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





      '''simple docstring'''






      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             lowercase__      			= 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   ,						)

             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.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

             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   __lowerCAmelCase						(unittest.TestCase  ,     lowercase_     ):





      '''simple docstring'''






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

             '''simple docstring'''







             lowercase__      			= TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
             lowercase__      			= 2
             lowercase__      			= 2
             class   __lowerCAmelCase						(tf.Module     ):





                   '''simple docstring'''






                   def __init__(self    :    str   ,						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    :    Optional[Any]   ,						UpperCamelCase    :    str   ,						UpperCamelCase    :    Optional[int] ):

                          '''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    :    Optional[Any] ):

             '''simple docstring'''







             lowercase__      			= TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
             lowercase__      			= 1
             lowercase__      			= 2
             class   __lowerCAmelCase						(tf.Module     ):





                   '''simple docstring'''






                   def __init__(self    :    Tuple   ,						UpperCamelCase    :    Tuple ):

                          '''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    :    Optional[int]   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    Optional[int] ):

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

             '''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   __lowerCAmelCase						(tf.keras.layers.Layer     ):





                          '''simple docstring'''






                          def __init__(self    :    Tuple ):

                                 '''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    :    str   ,						UpperCamelCase    :    Tuple   ,						*UpperCamelCase    :    str   ,						**UpperCamelCase    :    Tuple ):

                                 '''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    :    Union[str, Any] ):

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

             '''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   __lowerCAmelCase						(lowercase_     ):





                   '''simple docstring'''






                   def       UpperCamelCase__		(self    :    int   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    int=None   ,						**UpperCamelCase    :    Union[str, Any] ):

                          '''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   __lowerCAmelCase						(bart_model.model.encoder.__class__     ):





                   '''simple docstring'''






                   def       UpperCamelCase__		(self    :    Any   ,						UpperCamelCase    :    int   ,						**UpperCamelCase    :    str ):

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








'''simple docstring'''

from __future__ import annotations

def _SCREAMING_SNAKE_CASE      (A  , A       )       ->       list[list[int]]:






       """simple docstring"""







       lowercase__      			= []
       create_all_state(1  , A  , A  , []  , A       )
       return result

def _SCREAMING_SNAKE_CASE      (A  , A  , A  , A  , A  , )       ->       None:






       """simple docstring"""







       if level == 0:
              total_list.append(current_list[:]       )
              return

       for i in range(A  , total_number - level + 2       ):
              current_list.append(A       )
              create_all_state(i + 1  , A  , level - 1  , A  , A       )
              current_list.pop()

def _SCREAMING_SNAKE_CASE      (A       )       ->       None:






       """simple docstring"""







       for i in total_list:
              print(*A       )


if __name__ == "__main__":
 lowerCamelCase							:   Tuple  						=	4
 lowerCamelCase							:   Union[str, Any]  						=	2
 lowerCamelCase							:   Dict  						=	generate_all_combinations(n, k)
 print_all_state(total_list)




