
"""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     _SCREAMING_SNAKE_CASE   (			self  :   Any   )  -> Union[str, Any]:
							A     = 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	,)

							A     = 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

							A     = 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

							A     = tf_top_k_top_p_filtering(A_	,top_k=10	,top_p=0.6	,min_tokens_to_keep=4   )

							A     = output[output != -float('inf'   )]
							A     = 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 					lowerCAmelCase_					(   unittest.TestCase		,       _lowercase     ):



						'''simple docstring'''


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







							class 					lowerCAmelCase_					(   tf.Module     ):



													'''simple docstring'''


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

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


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







							class 					lowerCAmelCase_					(   tf.Module     ):



													'''simple docstring'''


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

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


						@slow
						@require_tensorflow_text
						def     _SCREAMING_SNAKE_CASE   (			self  :   Any   )  -> 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=A_   )







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



														'''simple docstring'''


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




														def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple	,A_  :   int	,*A_  :   Optional[int]	,**A_  :   Optional[int]   )  -> Union[str, Any]:
															A     = self.tokenizer.tokenize(A_   )
															A ,   A     = text.pad_model_inputs(
															    A_	,max_seq_length=64	,pad_value=self.model.config.pad_token_id   )
															A     = self.model.generate(input_ids=A_	,attention_mask=A_   )
															return self.tokenizer.detokenize(A_   )

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


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

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

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

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




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







							class 					lowerCAmelCase_					(   _lowercase     ):



													'''simple docstring'''


													def     _SCREAMING_SNAKE_CASE   (			self  :   Union[str, Any]	,A_  :   str	,A_  :   Optional[Any]=None	,**A_  :   Optional[int]   )  -> Dict:
														return super().call(A_	,**A_   )

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







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



													'''simple docstring'''


													def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple	,A_  :   Any	,**A_  :   Optional[Any]   )  -> str:
														return super().call(A_	,**A_   )

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

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







def 						_A      ( UpperCAmelCase = 1      ,UpperCAmelCase = 1000						):






   '''simple docstring'''







   A__       =     1
   A__       =     0

   for divide_by_number in range(UpperCAmelCase      ,digit + 1						):
      A__       =     []
      A__       =     numerator
      for _ in range(1      ,digit + 1						):
         if now_divide in has_been_divided:
            if longest_list_length < len(UpperCAmelCase						):
               A__       =     len(UpperCAmelCase						)
               A__       =     divide_by_number
         else:
            has_been_divided.append(UpperCAmelCase						)
            A__       =     now_divide * 10 % divide_by_number

   return the_digit


# Tests
if __name__ == "__main__":
    import doctest

    doctest.testmod()


