






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






						def      __snake_case      (		self  :Optional[int]				)      ->List[str]:
										lowercase    :      str       = tf.convert_to_tensor(
										    [
										        [
										            8.222_0991,  # 3rd highest value; idx. 0
										            -0.562_0044,
										            5.2322_9752,
										            4.038_6393,
										            -6.879_8378,
										            -0.5478_5802,
										            -3.201_2153,
										            2.9277_7176,
										            1.8817_1953,
										            7.3534_1276,  # 5th highest value; idx. 9
										            8.4320_7833,  # 2nd highest value; idx. 10
										            -9.8571_1836,
										            -5.9620_9236,
										            -1.1303_9161,
										            -7.111_5294,
										            -0.836_9633,
										            -5.318_6408,
										            7.0642_7407,
										            0.8136_9344,
										            -0.8202_3817,
										            -5.917_9796,
										            0.5881_3443,
										            -6.9977_8438,
										            4.7155_1189,
										            -0.1877_1637,
										            7.4402_0759,  # 4th highest value; idx. 25
										            9.3845_0987,  # 1st highest value; idx. 26
										            2.1266_2941,
										            -9.3256_2038,
										            2.3565_2522,
										        ],  # cummulative prob of 5 highest values <= 0.6
										        [
										            0.5842_5518,
										            4.5313_9238,
										            -5.5751_0464,
										            -6.2803_0699,
										            -7.1952_9503,
										            -4.0212_2551,
										            1.3933_7037,
										            -6.0670_7057,
										            1.5948_0517,
										            -9.64_3119,
										            0.0390_7799,
										            0.6723_1762,
										            -8.8820_6726,
										            6.2711_5922,  # 4th highest value; idx. 13
										            2.2852_0723,
										            4.8276_7506,
										            4.3042_1368,
										            8.827_5313,  # 2nd highest value; idx. 17
										            5.4402_9958,  # 5th highest value; idx. 18
										            -4.473_5794,
										            7.3857_9536,  # 3rd highest value; idx. 20
										            -2.9105_1663,
										            2.6194_6077,
										            -2.567_4762,
										            -9.4895_9302,
										            -4.0292_2645,
										            -1.3541_6918,
										            9.6770_2323,  # 1st highest value; idx. 27
										            -5.8947_8553,
										            1.8537_0467,
										        ],  # cummulative prob of 5 highest values <= 0.6
										    ]			, dtype=tf.floataa			, )

										lowercase    :      int       = 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    :      Optional[int]       = tf.convert_to_tensor(
										    [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023]			, dtype=tf.floataa			, )  # expected non filtered values as noted above

										lowercase    :      int       = tf_top_k_top_p_filtering(__magic_name__			, top_k=10			, top_p=0.6			, min_tokens_to_keep=4				)

										lowercase    :      Optional[int]       = output[output != -float("""inf"""				)]
										lowercase    :      List[str]       = tf.cast(
										    tf.where(tf.not_equal(__magic_name__			, tf.constant(-float("""inf"""				)			, dtype=tf.floataa				)				)				)			, dtype=tf.intaa			, )

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


@require_tf
class      UpperCamelCase		(unittest.TestCase						,						__snake_case     ):
						# setting framework_dependent_parameters needs to be gated, just like its contents' imports
						if is_tf_available():
												_SCREAMING_SNAKE_CASE  : str												=		{
												    """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      __snake_case      (		self  :List[str]				)      ->Optional[int]:
										# TF-only test: tf.saved_model export
										lowercase    :      Optional[Any]       = TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""				)
										lowercase    :      Any       = 2
										lowercase    :      Tuple       = 2


										class      UpperCamelCase		(tf.Module     ):






																def __init__(		self  :Optional[int]			, __magic_name__  :Union[str, Any]				)      ->int:
																				super(__magic_name__			, self				).__init__()
																				lowercase    :      Dict       = 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=__magic_name__			, )
																def      __snake_case      (		self  :List[Any]			, __magic_name__  :Dict			, __magic_name__  :Optional[Any]				)      ->int:
																				lowercase    :      Union[str, Any]       = self.model.generate(
																				    input_ids=__magic_name__			, attention_mask=__magic_name__			, max_new_tokens=__magic_name__			, return_dict_in_generate=__magic_name__			, )
																				return {"sequences": outputs["sequences"]}
										lowercase    :      int       = [[2, 0], [102, 103]]
										lowercase    :      Tuple       = [[1, 0], [1, 1]]
										lowercase    :      int       = DummyModel(model=__magic_name__				)
										with tempfile.TemporaryDirectory() as tmp_dir:
														tf.saved_model.save(__magic_name__			, __magic_name__			, signatures={"""serving_default""": dummy_model.serving}				)
														lowercase    :      Tuple       = tf.saved_model.load(__magic_name__				).signatures["""serving_default"""]
														for batch_size in range(1			, len(__magic_name__				) + 1				):
																		lowercase    :      Tuple       = {
																		    """input_ids""": tf.constant(dummy_input_ids[:batch_size]				),
																		    """attention_mask""": tf.constant(dummy_attention_masks[:batch_size]				),
																		}
																		lowercase    :      List[Any]       = serving_func(**__magic_name__				)["""sequences"""]
																		lowercase    :      List[Any]       = test_model.generate(**__magic_name__			, max_new_tokens=__magic_name__				)
																		tf.debugging.assert_equal(__magic_name__			, __magic_name__				)






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


										class      UpperCamelCase		(tf.Module     ):






																def __init__(		self  :Optional[Any]			, __magic_name__  :Optional[Any]				)      ->Any:
																				super(__magic_name__			, self				).__init__()
																				lowercase    :      Optional[Any]       = 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=__magic_name__			, )
																def      __snake_case      (		self  :str			, __magic_name__  :Optional[int]			, __magic_name__  :Dict				)      ->Dict:
																				lowercase    :      Dict       = self.model.generate(
																				    input_ids=__magic_name__			, attention_mask=__magic_name__			, max_new_tokens=__magic_name__			, return_dict_in_generate=__magic_name__			, )
																				return {"sequences": outputs["sequences"]}
										lowercase    :      str       = [[2], [102, 103]]
										lowercase    :      int       = [[1], [1, 1]]
										lowercase    :      int       = DummyModel(model=__magic_name__				)
										with tempfile.TemporaryDirectory() as tmp_dir:
														tf.saved_model.save(__magic_name__			, __magic_name__			, signatures={"""serving_default""": dummy_model.serving}				)
														lowercase    :      List[str]       = tf.saved_model.load(__magic_name__				).signatures["""serving_default"""]
														for input_row in range(len(__magic_name__				)				):
																		lowercase    :      Tuple       = {
																		    """input_ids""": tf.constant([dummy_input_ids[input_row]]				),
																		    """attention_mask""": tf.constant([dummy_attention_masks[input_row]]				),
																		}
																		lowercase    :      Optional[int]       = serving_func(**__magic_name__				)["""sequences"""]
																		lowercase    :      Tuple       = test_model.generate(**__magic_name__			, max_new_tokens=__magic_name__				)
																		tf.debugging.assert_equal(__magic_name__			, __magic_name__				)






						@slow
						@require_tensorflow_text
						def      __snake_case      (		self  :List[str]				)      ->Optional[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=__magic_name__				)


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






																				def __init__(		self  :Tuple				)      ->Any:
																								super().__init__()
																								lowercase    :      Any       = text.SentencepieceTokenizer(
																								    model=tf.io.gfile.GFile(os.path.join(__magic_name__			, """spiece.model"""				)			, """rb"""				).read()				)
																								lowercase    :      Union[str, Any]       = TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""				)






																				def      __snake_case      (		self  :List[str]			, __magic_name__  :Union[str, Any]			, *__magic_name__  :Optional[int]			, **__magic_name__  :Tuple				)      ->Union[str, Any]:
																								lowercase    :      Any       = self.tokenizer.tokenize(__magic_name__				)
																								lowercase      ,      lowercase    :      Optional[Any]       = text.pad_model_inputs(
																								    __magic_name__			, max_seq_length=64			, pad_value=self.model.config.pad_token_id				)
																								lowercase    :      Union[str, Any]       = self.model.generate(input_ids=__magic_name__			, attention_mask=__magic_name__				)
																								return self.tokenizer.detokenize(__magic_name__				)
														lowercase    :      int       = CompleteSentenceTransformer()
														lowercase    :      List[str]       = tf.keras.layers.Input(shape=(1,)			, dtype=tf.string			, name="""inputs"""				)
														lowercase    :      Tuple       = complete_model(__magic_name__				)
														lowercase    :      Optional[Any]       = tf.keras.Model(__magic_name__			, __magic_name__				)
														keras_model.save(__magic_name__				)






						def      __snake_case      (		self  :Union[str, Any]				)      ->Tuple:
										# Has PT equivalent: this test relies on random sampling
										lowercase    :      Any       = {
										    """do_sample""": True,
										    """num_beams""": 1,
										    """top_p""": 0.7,
										    """top_k""": 10,
										    """temperature""": 0.7,
										}
										lowercase    :      Optional[int]       = 14

										lowercase    :      Any       = AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""				)
										lowercase    :      Any       = """Hello, my dog is cute and"""
										lowercase    :      str       = tokenizer(__magic_name__			, return_tensors="""tf"""				)
										lowercase    :      Optional[Any]       = 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    :      List[str]       = model.generate(**__magic_name__			, eos_token_id=__magic_name__			, **__magic_name__				)
										self.assertTrue(expectation == len(generated_tokens[0]				)				)

										lowercase    :      List[str]       = [638, 198]
										with tf.device(""":/CPU:0"""				):
														tf.random.set_seed(0				)
														lowercase    :      int       = model.generate(**__magic_name__			, eos_token_id=__magic_name__			, **__magic_name__				)
										self.assertTrue(expectation == len(generated_tokens[0]				)				)






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


										class      UpperCamelCase		(__snake_case     ):






																def      __snake_case      (		self  :Dict			, __magic_name__  :str			, __magic_name__  :List[Any]=None			, **__magic_name__  :Tuple				)      ->Any:
																				return super().call(__magic_name__			, **__magic_name__				)
										lowercase    :      List[str]       = FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""				)
										lowercase    :      Tuple       = bart_model.generate(__magic_name__			, foo="""bar"""				).numpy()
										self.assertTrue(np.array_equal(__magic_name__			, __magic_name__				)				)


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






																def      __snake_case      (		self  :Union[str, Any]			, __magic_name__  :Optional[int]			, **__magic_name__  :Tuple				)      ->Optional[int]:
																				return super().call(__magic_name__			, **__magic_name__				)
										lowercase    :      Optional[int]       = 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    :      List[Any]       = bart_model.generate(__magic_name__				).numpy()
										with self.assertRaises(__magic_name__				):
														# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
														bart_model.generate(__magic_name__			, foo="""bar"""				)








"""simple docstring"""







from __future__ import annotations

from scipy.special import comb  # type: ignore


class      UpperCamelCase		:






						def __init__(		self  :Any			, __magic_name__  :list[tuple[float, float]]				)      ->str:
										lowercase    :      List[Any]       = list_of_points
										# Degree determines the flexibility of the curve.
										# Degree = 1 will produce a straight line.
										lowercase    :      Optional[int]       = len(__magic_name__				) - 1






						def      __snake_case      (		self  :List[str]			, __magic_name__  :float				)      ->list[float]:
										assert 0 <= t <= 1, "Time t must be between 0 and 1."
										lowercase    :      list[float]       = []
										for i in range(len(self.list_of_points				)				):
														# basis function for each i
														output_values.append(
														    comb(self.degree			, __magic_name__				) * ((1 - t) ** (self.degree - i)) * (t**i)				)
										# the basis must sum up to 1 for it to produce a valid Bezier curve.
										assert round(sum(__magic_name__				)			, 5				) == 1
										return output_values






						def      __snake_case      (		self  :List[str]			, __magic_name__  :float				)      ->tuple[float, float]:
										assert 0 <= t <= 1, "Time t must be between 0 and 1."

										lowercase    :      str       = self.basis_function(__magic_name__				)
										lowercase    :      Optional[int]       = 0.0
										lowercase    :      List[str]       = 0.0
										for i in range(len(self.list_of_points				)				):
														# For all points, sum up the product of i-th basis function and i-th point.
														x += basis_function[i] * self.list_of_points[i][0]
														y += basis_function[i] * self.list_of_points[i][1]
										return (x, y)






						def      __snake_case      (		self  :Tuple			, __magic_name__  :float = 0.01				)      ->List[str]:
										from matplotlib import pyplot as plt  # type: ignore

										lowercase    :      list[float]       = []  # x coordinates of points to plot
										lowercase    :      list[float]       = []  # y coordinates of points to plot

										lowercase    :      int       = 0.0
										while t <= 1:
														lowercase    :      List[Any]       = self.bezier_curve_function(__magic_name__				)
														to_plot_x.append(value[0]				)
														to_plot_y.append(value[1]				)
														t += step_size

										lowercase    :      Union[str, Any]       = [i[0] for i in self.list_of_points]
										lowercase    :      Optional[int]       = [i[1] for i in self.list_of_points]

										plt.plot(
										    __magic_name__			, __magic_name__			, color="""blue"""			, label="""Curve of Degree """ + str(self.degree				)			, )
										plt.scatter(__magic_name__			, __magic_name__			, color="""red"""			, label="""Control Points"""				)
										plt.legend()
										plt.show()


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				BezierCurve([(1, 2), (3, 5)]).plot_curve()  # degree 1
				BezierCurve([(0, 0), (5, 5), (5, 0)]).plot_curve()  # degree 2
				BezierCurve([(0, 0), (5, 5), (5, 0), (2.5, -2.5)]).plot_curve()  # degree 3
