
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        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      def A_      (      self			):
          snake_case__    =					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		,						)

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

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

          snake_case__    =					tf_top_k_top_p_filtering(lowerCamelCase		,						top_k=10		,						top_p=0.6		,						min_tokens_to_keep=4			)

          snake_case__    =					output[output != -float("inf"			)]
          snake_case__    =					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        _SCREAMING_SNAKE_CASE	(   unittest.TestCase							,       __UpperCamelCase			):
      # setting framework_dependent_parameters needs to be gated, just like its contents' imports
      if is_tf_available():
            _A    :		List[Any]     						=  {
                '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 A_      (      self			):
          # TF-only test: tf.saved_model export
          snake_case__    =					TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"			)
          snake_case__    =					2
          snake_case__    =					2




          class        _SCREAMING_SNAKE_CASE	(   tf.Module			):
                def __init__(      self		,						lowerCamelCase			):
                    super(lowerCamelCase		,						self			).__init__()
                    snake_case__    =					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 A_      (      self		,						lowerCamelCase		,						lowerCamelCase			):
                    snake_case__    =					self.model.generate(
                        input_ids=lowerCamelCase		,						attention_mask=lowerCamelCase		,						max_new_tokens=lowerCamelCase		,						return_dict_in_generate=lowerCamelCase		,						)
                    return {"sequences": outputs["sequences"]}





          snake_case__    =					[[2, 0], [1_02, 1_03]]
          snake_case__    =					[[1, 0], [1, 1]]
          snake_case__    =					DummyModel(model=lowerCamelCase			)
          with tempfile.TemporaryDirectory() as tmp_dir:
              tf.saved_model.save(lowerCamelCase		,						lowerCamelCase		,						signatures={"serving_default": dummy_model.serving}			)
              snake_case__    =					tf.saved_model.load(lowerCamelCase			).signatures["serving_default"]
              for batch_size in range(1		,						len(lowerCamelCase			) + 1			):
                  snake_case__    =					{
                      "input_ids": tf.constant(dummy_input_ids[:batch_size]			),
                      "attention_mask": tf.constant(dummy_attention_masks[:batch_size]			),
                  }
                  snake_case__    =					serving_func(**lowerCamelCase			)["sequences"]
                  snake_case__    =					test_model.generate(**lowerCamelCase		,						max_new_tokens=lowerCamelCase			)
                  tf.debugging.assert_equal(lowerCamelCase		,						lowerCamelCase			)
      @slow
      def A_      (      self			):
          # TF-only test: tf.saved_model export
          snake_case__    =					TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"			)
          snake_case__    =					1
          snake_case__    =					2




          class        _SCREAMING_SNAKE_CASE	(   tf.Module			):
                def __init__(      self		,						lowerCamelCase			):
                    super(lowerCamelCase		,						self			).__init__()
                    snake_case__    =					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 A_      (      self		,						lowerCamelCase		,						lowerCamelCase			):
                    snake_case__    =					self.model.generate(
                        input_ids=lowerCamelCase		,						attention_mask=lowerCamelCase		,						max_new_tokens=lowerCamelCase		,						return_dict_in_generate=lowerCamelCase		,						)
                    return {"sequences": outputs["sequences"]}





          snake_case__    =					[[2], [1_02, 1_03]]
          snake_case__    =					[[1], [1, 1]]
          snake_case__    =					DummyModel(model=lowerCamelCase			)
          with tempfile.TemporaryDirectory() as tmp_dir:
              tf.saved_model.save(lowerCamelCase		,						lowerCamelCase		,						signatures={"serving_default": dummy_model.serving}			)
              snake_case__    =					tf.saved_model.load(lowerCamelCase			).signatures["serving_default"]
              for input_row in range(len(lowerCamelCase			)			):
                  snake_case__    =					{
                      "input_ids": tf.constant([dummy_input_ids[input_row]]			),
                      "attention_mask": tf.constant([dummy_attention_masks[input_row]]			),
                  }
                  snake_case__    =					serving_func(**lowerCamelCase			)["sequences"]
                  snake_case__    =					test_model.generate(**lowerCamelCase		,						max_new_tokens=lowerCamelCase			)
                  tf.debugging.assert_equal(lowerCamelCase		,						lowerCamelCase			)
      @slow
      @require_tensorflow_text
      def A_      (      self			):
          # 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        _SCREAMING_SNAKE_CASE	(   tf.keras.layers.Layer			):
                    def __init__(      self			):
                        super().__init__()
                        snake_case__    =					text.SentencepieceTokenizer(
                            model=tf.io.gfile.GFile(os.path.join(lowerCamelCase		,						"spiece.model"			)		,						"rb"			).read()			)
                        snake_case__    =					TFAutoModelForSeqaSeqLM.from_pretrained("hf-internal-testing/tiny-random-t5"			)



                    def A_      (      self		,						lowerCamelCase		,						*lowerCamelCase		,						**lowerCamelCase			):
                        snake_case__    =					self.tokenizer.tokenize(lowerCamelCase			)
                        snake_case__    ,       snake_case__    =					text.pad_model_inputs(
                            lowerCamelCase		,						max_seq_length=64		,						pad_value=self.model.config.pad_token_id			)
                        snake_case__    =					self.model.generate(input_ids=lowerCamelCase		,						attention_mask=lowerCamelCase			)
                        return self.tokenizer.detokenize(lowerCamelCase			)





              snake_case__    =					CompleteSentenceTransformer()
              snake_case__    =					tf.keras.layers.Input(shape=(1,)		,						dtype=tf.string		,						name="inputs"			)
              snake_case__    =					complete_model(lowerCamelCase			)
              snake_case__    =					tf.keras.Model(lowerCamelCase		,						lowerCamelCase			)
              keras_model.save(lowerCamelCase			)
      def A_      (      self			):
          # Has PT equivalent: this test relies on random sampling
          snake_case__    =					{
              "do_sample": True,
              "num_beams": 1,
              "top_p": 0.7,
              "top_k": 10,
              "temperature": 0.7,
          }
          snake_case__    =					14

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

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

          snake_case__    =					[6_38, 1_98]
          with tf.device(":/CPU:0"			):
              tf.random.set_seed(0			)
              snake_case__    =					model.generate(**lowerCamelCase		,						eos_token_id=lowerCamelCase		,						**lowerCamelCase			)
          self.assertTrue(expectation == len(generated_tokens[0]			)			)



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




          class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase			):
                def A_      (      self		,						lowerCamelCase		,						lowerCamelCase=None		,						**lowerCamelCase			):
                    return super().call(lowerCamelCase		,						**lowerCamelCase			)





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




          class        _SCREAMING_SNAKE_CASE	(   bart_model.model.encoder.__class__			):
                def A_      (      self		,						lowerCamelCase		,						**lowerCamelCase			):
                    return super().call(lowerCamelCase		,						**lowerCamelCase			)





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

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





from __future__ import annotations

import math





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5     ,		int(math.sqrt(__lowerCAmelCase				) + 1				)     ,		6				):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    snake_case__    =					str(__lowerCAmelCase				)
    snake_case__    =					[n]
    for i in range(1     ,		len(__lowerCAmelCase				)				):
        list_nums.append(int(str_num[i:]				)				)
        list_nums.append(int(str_num[:-i]				)				)
    return list_nums





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    if len(str(__lowerCAmelCase				)				) > 3:
        if not is_prime(int(str(__lowerCAmelCase				)[-3:]				)				) or not is_prime(int(str(__lowerCAmelCase				)[:3]				)				):
            return False
    return True





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase = 11				):
    snake_case__    =					[]
    snake_case__    =					13
    while len(__lowerCAmelCase				) != count:
        if validate(__lowerCAmelCase				):
            snake_case__    =					list_truncated_nums(__lowerCAmelCase				)
            if all(is_prime(__lowerCAmelCase				) for i in list_nums				):
                list_truncated_primes.append(__lowerCAmelCase				)
        num += 2
    return list_truncated_primes





def 						SCREAMING_SNAKE_CASE__     (   ):
    return sum(compute_truncated_primes(11				)				)


if __name__ == "__main__":
     print(F'''{sum(compute_truncated_primes(11)) = }''')



