




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







   def 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     __a								=       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   ,				)

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

     __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  __lowercase    (	unittest.TestCase							,				_lowercase			):


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





     class  __lowercase    (	tf.Module			):







        def __init__(						self   ,				UpperCamelCase   )					->     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 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     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 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     # TF-only test: tf.saved_model export
     __a								=       TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'   )
     __a								=       1
     __a								=       2





     class  __lowercase    (	tf.Module			):







        def __init__(						self   ,				UpperCamelCase   )					->     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 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     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 		UpperCamelCase__      (						self   )					->     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  __lowercase    (	tf.keras.layers.Layer			):







          def __init__(						self   )					->     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 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				*UpperCamelCase   ,				**UpperCamelCase   )					->     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 		UpperCamelCase__      (						self   )					->     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 		UpperCamelCase__      (						self   )					->     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  __lowercase    (	_lowercase			):







        def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase=None   ,				**UpperCamelCase   )					->     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  __lowercase    (	bart_model.model.encoder.__class__			):







        def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				**UpperCamelCase   )					->     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"""


import os

# Precomputes a list of the 100 first triangular numbers
_lowercase				 =					[int(0.5 * n * (n + 1)) for n in range(1, 1_01)]






def    _snake_case					(		):
	A     = os.path.dirname(os.path.realpath(snake_case__  )  )
	A     = os.path.join(snake_case__						,   'words.txt'  )

	A     = ''
	with open(snake_case__  ) as f:
		A     = f.readline()

	A     = [word.strip('"'  ) for word in words.strip('\r\n'  ).split(','  )]
	A     = [
	    word
	    for word in [sum(ord(snake_case__  ) - 64 for x in word  ) for word in words]
	    if word in TRIANGULAR_NUMBERS
	]
	return len(snake_case__  )


if __name__ == "__main__":
		print(solution())