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





       '''simple docstring'''



       def _lowerCAmelCase(						self )  ->  Dict:
        lowercase__				:    int  =					tf.convert_to_tensor(
            [
                [
                    8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
                    -0.5_6_2_0_0_4_4,
                    5.2_3_2_2_9_7_5_2,
                    4.0_3_8_6_3_9_3,
                    -6.8_7_9_8_3_7_8,
                    -0.5_4_7_8_5_8_0_2,
                    -3.2_0_1_2_1_5_3,
                    2.9_2_7_7_7_1_7_6,
                    1.8_8_1_7_1_9_5_3,
                    7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
                    8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
                    -9.8_5_7_1_1_8_3_6,
                    -5.9_6_2_0_9_2_3_6,
                    -1.1_3_0_3_9_1_6_1,
                    -7.1_1_1_5_2_9_4,
                    -0.8_3_6_9_6_3_3,
                    -5.3_1_8_6_4_0_8,
                    7.0_6_4_2_7_4_0_7,
                    0.8_1_3_6_9_3_4_4,
                    -0.8_2_0_2_3_8_1_7,
                    -5.9_1_7_9_7_9_6,
                    0.5_8_8_1_3_4_4_3,
                    -6.9_9_7_7_8_4_3_8,
                    4.7_1_5_5_1_1_8_9,
                    -0.1_8_7_7_1_6_3_7,
                    7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
                    9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
                    2.1_2_6_6_2_9_4_1,
                    -9.3_2_5_6_2_0_3_8,
                    2.3_5_6_5_2_5_2_2,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.5_8_4_2_5_5_1_8,
                    4.5_3_1_3_9_2_3_8,
                    -5.5_7_5_1_0_4_6_4,
                    -6.2_8_0_3_0_6_9_9,
                    -7.1_9_5_2_9_5_0_3,
                    -4.0_2_1_2_2_5_5_1,
                    1.3_9_3_3_7_0_3_7,
                    -6.0_6_7_0_7_0_5_7,
                    1.5_9_4_8_0_5_1_7,
                    -9.6_4_3_1_1_9,
                    0.0_3_9_0_7_7_9_9,
                    0.6_7_2_3_1_7_6_2,
                    -8.8_8_2_0_6_7_2_6,
                    6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
                    2.2_8_5_2_0_7_2_3,
                    4.8_2_7_6_7_5_0_6,
                    4.3_0_4_2_1_3_6_8,
                    8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
                    5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
                    -4.4_7_3_5_7_9_4,
                    7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
                    -2.9_1_0_5_1_6_6_3,
                    2.6_1_9_4_6_0_7_7,
                    -2.5_6_7_4_7_6_2,
                    -9.4_8_9_5_9_3_0_2,
                    -4.0_2_9_2_2_6_4_5,
                    -1.3_5_4_1_6_9_1_8,
                    9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
                    -5.8_9_4_7_8_5_5_3,
                    1.8_5_3_7_0_4_6_7,
                ],  # cummulative prob of 5 highest values <= 0.6
            ]	,   dtype=tf.floataa	,   )

        lowercase__				:    str  =					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__				:    Any  =					tf.convert_to_tensor(
            [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]	,   dtype=tf.floataa	,   )  # expected non filtered values as noted above

        lowercase__				:    List[Any]  =					tf_top_k_top_p_filtering(__lowerCAmelCase	,   top_k=10	,   top_p=0.6	,   min_tokens_to_keep=4 )

        lowercase__				:    List[Any]  =					output[output != -float('''inf''' )]
        lowercase__				:    Union[str, Any]  =					tf.cast(
            tf.where(tf.not_equal(__lowerCAmelCase	,   tf.constant(-float('''inf''' )	,   dtype=tf.floataa ) ) )	,   dtype=tf.intaa	,   )

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



@require_tf
class 			UpperCAmelCase  (						unittest.TestCase    ,						a__					):





       '''simple docstring'''



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



        class 			UpperCAmelCase  (						tf.Module					):





               '''simple docstring'''



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


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

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



        class 			UpperCAmelCase  (						tf.Module					):





               '''simple docstring'''



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


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

       @slow
       @require_tensorflow_text
       def _lowerCAmelCase(						self )  ->  List[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=__lowerCAmelCase )



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





                '''simple docstring'''



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


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


         lowercase__				:    List[Any]  =					CompleteSentenceTransformer()
         lowercase__				:    Tuple  =					tf.keras.layers.Input(shape=(1,)	,   dtype=tf.string	,   name='''inputs''' )
         lowercase__				:    Tuple  =					complete_model(__lowerCAmelCase )
         lowercase__				:    Optional[int]  =					tf.keras.Model(__lowerCAmelCase	,   __lowerCAmelCase )
         keras_model.save(__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Optional[int]:
        # Has PT equivalent: this test relies on random sampling
        lowercase__				:    int  =					{
            '''do_sample''': True,
            '''num_beams''': 1,
            '''top_p''': 0.7,
            '''top_k''': 10,
            '''temperature''': 0.7,
        }
        lowercase__				:    List[str]  =					14

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

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

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


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



        class 			UpperCAmelCase  (						a__					):





               '''simple docstring'''



               def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase=None	,   **__lowerCAmelCase )  ->  Union[str, Any]:
                return super().call(__lowerCAmelCase	,   **__lowerCAmelCase )


        lowercase__				:    str  =					FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart''' )
        lowercase__				:    Tuple  =					bart_model.generate(__lowerCAmelCase	,   foo='''bar''' ).numpy()
        self.assertTrue(np.array_equal(__lowerCAmelCase	,   __lowerCAmelCase ) )



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





               '''simple docstring'''



               def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   **__lowerCAmelCase )  ->  Optional[int]:
                return super().call(__lowerCAmelCase	,   **__lowerCAmelCase )


        lowercase__				:    List[str]  =					FakeEncoder(bart_model.config	,   bart_model.model.shared )
        lowercase__				:    Optional[Any]  =					fake_encoder

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


'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    List[str]  =					0
 while num > 0:
  digit_sum += num % 10
  num //= 10
 return digit_sum
def 			__UpperCamelCase       (   UpperCAmelCase = 100     ):
 lowercase__				:    Dict  =					1
 lowercase__				:    Optional[int]  =					2

 for i in range(2		,     max_n + 1     ):
  lowercase__				:    List[str]  =					pre_numerator
  lowercase__				:    Optional[Any]  =					2 * i // 3 if i % 3 == 0 else 1
  lowercase__				:    Union[str, Any]  =					cur_numerator
  lowercase__				:    int  =					e_cont * pre_numerator + temp

 return sum_digits(UpperCAmelCase     )


if __name__ == "__main__":
  print(F'{solution() = }')

