






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


  """simple docstring"""


  def    _a       (			self	):






         """simple docstring"""


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

         tf.debugging.assert_near(UpperCamelCase__   ,	UpperCamelCase__   ,	rtol=1e-12	)
         tf.debugging.assert_equal(UpperCamelCase__   ,	UpperCamelCase__	)





@require_tf
class   __SCREAMING_SNAKE_CASE       (unittest.TestCase							,       __A       ):


  """simple docstring"""


  if is_tf_available():
    _a  : Dict      			=     {
        '''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	):






         """simple docstring"""


         a_						     =			TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'	)
         a_						     =			2
         a_						     =			2




         class   __SCREAMING_SNAKE_CASE       (tf.Module       ):


           """simple docstring"""


           def __init__(			self   ,	UpperCamelCase__	):






                  """simple docstring"""


                  super(UpperCamelCase__   ,	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=UpperCamelCase__   ,	)
           def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__	):






                  """simple docstring"""


                  a_						     =			self.model.generate(
                      input_ids=UpperCamelCase__   ,	attention_mask=UpperCamelCase__   ,	max_new_tokens=UpperCamelCase__   ,	return_dict_in_generate=UpperCamelCase__   ,	)
                  return {"sequences": outputs["sequences"]}





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







  @slow
  def    _a       (			self	):






         """simple docstring"""


         a_						     =			TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'	)
         a_						     =			1
         a_						     =			2




         class   __SCREAMING_SNAKE_CASE       (tf.Module       ):


           """simple docstring"""


           def __init__(			self   ,	UpperCamelCase__	):






                  """simple docstring"""


                  super(UpperCamelCase__   ,	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=UpperCamelCase__   ,	)
           def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__	):






                  """simple docstring"""


                  a_						     =			self.model.generate(
                      input_ids=UpperCamelCase__   ,	attention_mask=UpperCamelCase__   ,	max_new_tokens=UpperCamelCase__   ,	return_dict_in_generate=UpperCamelCase__   ,	)
                  return {"sequences": outputs["sequences"]}





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







  @slow
  @require_tensorflow_text
  def    _a       (			self	):






         """simple docstring"""


         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=UpperCamelCase__	)




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


                  """simple docstring"""


                  def __init__(			self	):






                         """simple docstring"""


                         super().__init__()
                         a_						     =			text.SentencepieceTokenizer(
                             model=tf.io.gfile.GFile(os.path.join(UpperCamelCase__   ,	'spiece.model'	)   ,	'rb'	).read()	)
                         a_						     =			TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'	)







                  def    _a       (			self   ,	UpperCamelCase__   ,	*UpperCamelCase__   ,	**UpperCamelCase__	):






                         """simple docstring"""


                         a_						     =			self.tokenizer.tokenize(UpperCamelCase__	)
                         a_     ,	a_						     =			text.pad_model_inputs(
                             UpperCamelCase__   ,	max_seq_length=64   ,	pad_value=self.model.config.pad_token_id	)
                         a_						     =			self.model.generate(input_ids=UpperCamelCase__   ,	attention_mask=UpperCamelCase__	)
                         return self.tokenizer.detokenize(UpperCamelCase__	)





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







  def    _a       (			self	):






         """simple docstring"""


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

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







  def    _a       (			self	):






         """simple docstring"""


         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(UpperCamelCase__   ,	return_tensors='tf'	).input_ids
         a_						     =			TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'	)
         a_						     =			bart_model.generate(UpperCamelCase__	).numpy()




         class   __SCREAMING_SNAKE_CASE       (__A       ):


           """simple docstring"""


           def    _a       (			self   ,	UpperCamelCase__   ,	UpperCamelCase__=None   ,	**UpperCamelCase__	):






                  """simple docstring"""


                  return super().call(UpperCamelCase__   ,	**UpperCamelCase__	)





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




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


           """simple docstring"""


           def    _a       (			self   ,	UpperCamelCase__   ,	**UpperCamelCase__	):






                  """simple docstring"""


                  return super().call(UpperCamelCase__   ,	**UpperCamelCase__	)





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












'''simple docstring'''







from math import isqrt, loga


def       __UpperCamelCase					(      lowercase_       :  int   ):
       """simple docstring"""




       a_						     =			[True] * max_number
       for i in range(2   ,       isqrt(max_number - 1   ) + 1   ):
              if is_prime[i]:
                     for j in range(i**2   ,       lowercase_   ,       lowercase_   ):
                            a_						     =			False

       return [i for i in range(2   ,       lowercase_   ) if is_prime[i]]


def       __UpperCamelCase					(      lowercase_       :  int = 800_800   ,       lowercase_       :  int = 800_800   ):
       """simple docstring"""




       a_						     =			degree * loga(lowercase_   )
       a_						     =			int(lowercase_   )
       a_						     =			calculate_prime_numbers(lowercase_   )

       a_						     =			0
       a_						     =			0
       a_						     =			len(lowercase_   ) - 1
       while left < right:
              while (
                  prime_numbers[right] * loga(prime_numbers[left]   )
                  + prime_numbers[left] * loga(prime_numbers[right]   )
                  > upper_bound
              ):
                     right -= 1
              hybrid_integers_count += right - left
              left += 1

       return hybrid_integers_count


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




