


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






     def  a_					(			self		)       ->    Dict:
          _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(__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 ,			lowerCamelCase__ ):
     # setting framework_dependent_parameters needs to be gated, just like its contents' imports
     if is_tf_available():
          UpperCAmelCase 					=				{
              '''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		)       ->    Union[str, Any]:
          # TF-only test: tf.saved_model export
          _a						=		TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
          _a						=		2
          _a						=		2





          class 						__SCREAMING_SNAKE_CASE					(      tf.Module ):






               def __init__(			self     ,							__UpperCamelCase		)       ->    Optional[int]:
                    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		)       ->    List[Any]:
                    _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		)       ->    Optional[Any]:
          # TF-only test: tf.saved_model export
          _a						=		TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
          _a						=		1
          _a						=		2





          class 						__SCREAMING_SNAKE_CASE					(      tf.Module ):






               def __init__(			self     ,							__UpperCamelCase		)       ->    Tuple:
                    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		)       ->    Union[str, Any]:
                    _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		)       ->    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=__UpperCamelCase		)





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






                    def __init__(			self		)       ->    int:
                         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		)       ->    Optional[Any]:
                         _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		)       ->    List[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(__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		)       ->    int:
          # 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(__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					(      lowerCamelCase__ ):






               def  a_					(			self     ,							__UpperCamelCase     ,							__UpperCamelCase=None     ,							**__UpperCamelCase		)       ->    List[Any]:
                    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__ ):






               def  a_					(			self     ,							__UpperCamelCase     ,							**__UpperCamelCase		)       ->    str:
                    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'''

import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin





class 						__SCREAMING_SNAKE_CASE					(      unittest.TestCase ,			lowerCamelCase__ ):






     def  a_					(			self		)       ->    Tuple:
          _a						=		load_tool("text-classification"		)
          self.tool.setup()
          _a						=		load_tool("text-classification"     ,							remote=__UpperCamelCase		)






     def  a_					(			self		)       ->    Optional[int]:
          _a						=		self.tool("That's quite cool"     ,							["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)






     def  a_					(			self		)       ->    Union[str, Any]:
          _a						=		self.remote_tool("That's quite cool"     ,							["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)






     def  a_					(			self		)       ->    Optional[int]:
          _a						=		self.tool(text="That's quite cool"     ,							labels=["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)






     def  a_					(			self		)       ->    str:
          _a						=		self.remote_tool(text="That's quite cool"     ,							labels=["positive", "negative"]		)
          self.assertEqual(__UpperCamelCase     ,							"positive"		)

