



"""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 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase							 =		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	,       )

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

									_UpperCAmelCase							 =		tf_top_k_top_p_filtering(snake_case	,       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(snake_case	,       tf.constant(-float('inf'						)	,       dtype=tf.floataa						)						)						)	,       dtype=tf.intaa	,       )

									tf.debugging.assert_near(snake_case	,       snake_case	,       rtol=1E-12						)
									tf.debugging.assert_equal(snake_case	,       snake_case						)







@require_tf
class 			lowercase__			(      unittest.TestCase,					A    ):
							'''simple docstring'''







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




									class 			lowercase__			(      tf.Module    ):
																'''simple docstring'''







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







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






							@slow
							def        lowerCamelCase_   (  self						)			->							int:
									# TF-only test: tf.saved_model export
									_UpperCAmelCase							 =		TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'						)
									_UpperCAmelCase							 =		1
									_UpperCAmelCase							 =		2




									class 			lowercase__			(      tf.Module    ):
																'''simple docstring'''







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







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






							@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=snake_case						)




											class 			lowercase__			(      tf.keras.layers.Layer    ):
																		'''simple docstring'''







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






																		def        lowerCamelCase_   (  self	,       snake_case	,       *snake_case	,       **snake_case						)			->							str:
																				_UpperCAmelCase							 =		self.tokenizer.tokenize(snake_case						)
																				_UpperCAmelCase ,					_UpperCAmelCase							 =		text.pad_model_inputs(
																				    snake_case	,       max_seq_length=64	,       pad_value=self.model.config.pad_token_id						)
																				_UpperCAmelCase							 =		self.model.generate(input_ids=snake_case	,       attention_mask=snake_case						)
																				return self.tokenizer.detokenize(snake_case						)







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






							def        lowerCamelCase_   (  self						)			->							List[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(snake_case	,       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(**snake_case	,       eos_token_id=snake_case	,       **snake_case						)
									self.assertTrue(expectation == len(generated_tokens[0]						)						)

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






							def        lowerCamelCase_   (  self						)			->							Dict:
									# 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(snake_case	,       return_tensors='tf'						).input_ids
									_UpperCAmelCase							 =		TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'						)
									_UpperCAmelCase							 =		bart_model.generate(snake_case						).numpy()




									class 			lowercase__			(      A    ):
																'''simple docstring'''







																def        lowerCamelCase_   (  self	,       snake_case	,       snake_case=None	,       **snake_case						)			->							str:
																		return super().call(snake_case	,       **snake_case						)







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




									class 			lowercase__			(      bart_model.model.encoder.__class__    ):
																'''simple docstring'''







																def        lowerCamelCase_   (  self	,       snake_case	,       **snake_case						)			->							int:
																		return super().call(snake_case	,       **snake_case						)







									_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(snake_case						).numpy()
									with self.assertRaises(snake_case						):
											# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
											bart_model.generate(snake_case	,       foo='bar'						)







"""simple docstring"""





from __future__ import annotations




def 	UpperCAmelCase     (		A	:						int     ,				A	:						int       ):

		'''simple docstring'''


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




def 	UpperCAmelCase     (		A	:						int     ,				A	:						int     ,				A	:						int     ,				A	:						list[int]     ,				A	:						list[list[int]]     ,				):

		'''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 	UpperCAmelCase     (		A	:						list[list[int]]       ):

		'''simple docstring'''


		for i in total_list:
				print(*A       )


if __name__ == "__main__":
					lowercase  							=					4
					lowercase  							=					2
					lowercase  							=					generate_all_combinations(n, k)
					print_all_state(total_list)


