

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







			def 				__UpperCamelCase			(      self				:			Dict						)				->							Optional[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   List[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   ,   )

				SCREAMING_SNAKE_CASE :   Optional[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

				SCREAMING_SNAKE_CASE :   List[Any]					  =							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

				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							tf_top_k_top_p_filtering(a   ,   top_k=10   ,   top_p=0.6   ,   min_tokens_to_keep=4						)

				SCREAMING_SNAKE_CASE :   List[Any]					  =							output[output != -float("inf"						)]
				SCREAMING_SNAKE_CASE :   Tuple					  =							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 _UpperCamelCase				(				unittest.TestCase				,						__A ):
			'''simple docstring'''







			if is_tf_available():
						lowerCamelCase__							     ={
						    '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[int]						)				->							Dict:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   Tuple					  =							TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"						)
				SCREAMING_SNAKE_CASE :   str					  =							2
				SCREAMING_SNAKE_CASE :   List[str]					  =							2






				class _UpperCamelCase				(				tf.Module ):
							'''simple docstring'''







							def __init__(      self				:			List[str]   ,   a				:			Optional[int]						)				->							str:

								"""simple docstring"""

								super(a   ,   self						).__init__()
								SCREAMING_SNAKE_CASE :   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=a   ,   )
							def 				__UpperCamelCase			(      self				:			Union[str, Any]   ,   a				:			List[str]   ,   a				:			Any						)				->							Tuple:

								"""simple docstring"""

								SCREAMING_SNAKE_CASE :   List[Any]					  =							self.model.generate(
								    input_ids=a   ,   attention_mask=a   ,   max_new_tokens=a   ,   return_dict_in_generate=a   ,   )
								return {"sequences": outputs["sequences"]}

				SCREAMING_SNAKE_CASE :   Dict					  =							[[2, 0], [102, 103]]
				SCREAMING_SNAKE_CASE :   Optional[int]					  =							[[1, 0], [1, 1]]
				SCREAMING_SNAKE_CASE :   Any					  =							DummyModel(model=a						)
				with tempfile.TemporaryDirectory() as tmp_dir:
					tf.saved_model.save(a   ,   a   ,   signatures={"serving_default": dummy_model.serving}						)
					SCREAMING_SNAKE_CASE :   Tuple					  =							tf.saved_model.load(a						).signatures["serving_default"]
					for batch_size in range(1   ,   len(a						) + 1						):
						SCREAMING_SNAKE_CASE :   Optional[int]					  =							{
						    "input_ids": tf.constant(dummy_input_ids[:batch_size]						),
						    "attention_mask": tf.constant(dummy_attention_masks[:batch_size]						),
						}
						SCREAMING_SNAKE_CASE :   Dict					  =							serving_func(**a						)["sequences"]
						SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							test_model.generate(**a   ,   max_new_tokens=a						)
						tf.debugging.assert_equal(a   ,   a						)
			@slow
			def 				__UpperCamelCase			(      self				:			Any						)				->							List[str]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   List[Any]					  =							TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"						)
				SCREAMING_SNAKE_CASE :   int					  =							1
				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							2






				class _UpperCamelCase				(				tf.Module ):
							'''simple docstring'''







							def __init__(      self				:			List[str]   ,   a				:			List[Any]						)				->							Optional[int]:

								"""simple docstring"""

								super(a   ,   self						).__init__()
								SCREAMING_SNAKE_CASE :   List[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=a   ,   )
							def 				__UpperCamelCase			(      self				:			str   ,   a				:			List[str]   ,   a				:			str						)				->							Any:

								"""simple docstring"""

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

				SCREAMING_SNAKE_CASE :   str					  =							[[2], [102, 103]]
				SCREAMING_SNAKE_CASE :   str					  =							[[1], [1, 1]]
				SCREAMING_SNAKE_CASE :   Optional[Any]					  =							DummyModel(model=a						)
				with tempfile.TemporaryDirectory() as tmp_dir:
					tf.saved_model.save(a   ,   a   ,   signatures={"serving_default": dummy_model.serving}						)
					SCREAMING_SNAKE_CASE :   List[Any]					  =							tf.saved_model.load(a						).signatures["serving_default"]
					for input_row in range(len(a						)						):
						SCREAMING_SNAKE_CASE :   List[str]					  =							{
						    "input_ids": tf.constant([dummy_input_ids[input_row]]						),
						    "attention_mask": tf.constant([dummy_attention_masks[input_row]]						),
						}
						SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							serving_func(**a						)["sequences"]
						SCREAMING_SNAKE_CASE :   str					  =							test_model.generate(**a   ,   max_new_tokens=a						)
						tf.debugging.assert_equal(a   ,   a						)
			@slow
			@require_tensorflow_text
			def 				__UpperCamelCase			(      self				:			Tuple						)				->							str:

				"""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=a						)






					class _UpperCamelCase				(				tf.keras.layers.Layer ):
								'''simple docstring'''







								def __init__(      self				:			Tuple						)				->							Optional[Any]:

									"""simple docstring"""

									super().__init__()
									SCREAMING_SNAKE_CASE :   List[str]					  =							text.SentencepieceTokenizer(
									    model=tf.io.gfile.GFile(os.path.join(a   ,   "spiece.model"						)   ,   "rb"						).read()						)
									SCREAMING_SNAKE_CASE :   str					  =							TFAutoModelForSeqaSeqLM.from_pretrained("hf-internal-testing/tiny-random-t5"						)






								def 				__UpperCamelCase			(      self				:			Union[str, Any]   ,   a				:			Optional[Any]   ,   *a				:			Union[str, Any]   ,   **a				:			int						)				->							List[str]:

									"""simple docstring"""

									SCREAMING_SNAKE_CASE :   List[Any]					  =							self.tokenizer.tokenize(a						)
									SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE :   Optional[int]					  =							text.pad_model_inputs(
									    a   ,   max_seq_length=64   ,   pad_value=self.model.config.pad_token_id						)
									SCREAMING_SNAKE_CASE :   str					  =							self.model.generate(input_ids=a   ,   attention_mask=a						)
									return self.tokenizer.detokenize(a						)

					SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							CompleteSentenceTransformer()
					SCREAMING_SNAKE_CASE :   Optional[Any]					  =							tf.keras.layers.Input(shape=(1,)   ,   dtype=tf.string   ,   name="inputs"						)
					SCREAMING_SNAKE_CASE :   Dict					  =							complete_model(a						)
					SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							tf.keras.Model(a   ,   a						)
					keras_model.save(a						)
			def 				__UpperCamelCase			(      self				:			int						)				->							Dict:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   List[str]					  =							{
				    "do_sample": True,
				    "num_beams": 1,
				    "top_p": 0.7,
				    "top_k": 10,
				    "temperature": 0.7,
				}
				SCREAMING_SNAKE_CASE :   Dict					  =							14

				SCREAMING_SNAKE_CASE :   int					  =							AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"						)
				SCREAMING_SNAKE_CASE :   int					  =							"Hello, my dog is cute and"
				SCREAMING_SNAKE_CASE :   Optional[Any]					  =							tokenizer(a   ,   return_tensors="tf"						)
				SCREAMING_SNAKE_CASE :   str					  =							TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"						)

				SCREAMING_SNAKE_CASE :   Dict					  =							638
				# forces the generation to happen on CPU, to avoid GPU-related quirks
				with tf.device(":/CPU:0"						):
					tf.random.set_seed(0						)
					SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							model.generate(**a   ,   eos_token_id=a   ,   **a						)
				self.assertTrue(expectation == len(generated_tokens[0]						)						)

				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							[638, 198]
				with tf.device(":/CPU:0"						):
					tf.random.set_seed(0						)
					SCREAMING_SNAKE_CASE :   Optional[Any]					  =							model.generate(**a   ,   eos_token_id=a   ,   **a						)
				self.assertTrue(expectation == len(generated_tokens[0]						)						)






			def 				__UpperCamelCase			(      self				:			Tuple						)				->							str:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   Tuple					  =							AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bart"						)
				SCREAMING_SNAKE_CASE :   Optional[int]					  =							"Hugging Face is a technology company based in New York and Paris."
				SCREAMING_SNAKE_CASE :   List[Any]					  =							bart_tokenizer(a   ,   return_tensors="tf"						).input_ids
				SCREAMING_SNAKE_CASE :   Dict					  =							TFBartForConditionalGeneration.from_pretrained("hf-internal-testing/tiny-random-bart"						)
				SCREAMING_SNAKE_CASE :   Dict					  =							bart_model.generate(a						).numpy()






				class _UpperCamelCase				(				__A ):
							'''simple docstring'''







							def 				__UpperCamelCase			(      self				:			Optional[int]   ,   a				:			int   ,   a				:			List[str]=None   ,   **a				:			List[str]						)				->							Optional[int]:

								"""simple docstring"""

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

				SCREAMING_SNAKE_CASE :   Optional[int]					  =							FakeBart.from_pretrained("hf-internal-testing/tiny-random-bart"						)
				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							bart_model.generate(a   ,   foo="bar"						).numpy()
				self.assertTrue(np.array_equal(a   ,   a						)						)






				class _UpperCamelCase				(				bart_model.model.encoder.__class__ ):
							'''simple docstring'''







							def 				__UpperCamelCase			(      self				:			Tuple   ,   a				:			Any   ,   **a				:			List[Any]						)				->							Optional[Any]:

								"""simple docstring"""

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

				SCREAMING_SNAKE_CASE :   int					  =							FakeEncoder(bart_model.config   ,   bart_model.model.shared						)
				SCREAMING_SNAKE_CASE :   List[str]					  =							fake_encoder

				# Normal generation still works (the output will be different because the encoder weights are different)
				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							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"						)


from math import pi, sqrt, tan

def 			lowerCamelCase__			(       _a):
	if side_length < 0:
		raise ValueError("surface_area_cube() only accepts non-negative values")
	return 6 * side_length**2

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if length < 0 or breadth < 0 or height < 0:
		raise ValueError("surface_area_cuboid() only accepts non-negative values")
	return 2 * ((length * breadth) + (breadth * height) + (length * height))

def 			lowerCamelCase__			(       _a):
	if radius < 0:
		raise ValueError("surface_area_sphere() only accepts non-negative values")
	return 4 * pi * radius**2

def 			lowerCamelCase__			(       _a):
	if radius < 0:
		raise ValueError("surface_area_hemisphere() only accepts non-negative values")
	return 3 * pi * radius**2

def 			lowerCamelCase__			(       _a				,      _a):
	if radius < 0 or height < 0:
		raise ValueError("surface_area_cone() only accepts non-negative values")
	return pi * radius * (radius + (height**2 + radius**2) ** 0.5)

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if radius_a < 0 or radius_a < 0 or height < 0:
		raise ValueError(
		    "surface_area_conical_frustum() only accepts non-negative values")
	SCREAMING_SNAKE_CASE :   Any					  =							(height**2 + (radius_a - radius_a) ** 2) ** 0.5
	return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)

def 			lowerCamelCase__			(       _a				,      _a):
	if radius < 0 or height < 0:
		raise ValueError("surface_area_cylinder() only accepts non-negative values")
	return 2 * pi * radius * (height + radius)

def 			lowerCamelCase__			(       _a				,      _a):
	if torus_radius < 0 or tube_radius < 0:
		raise ValueError("surface_area_torus() only accepts non-negative values")
	if torus_radius < tube_radius:
		raise ValueError(
		    "surface_area_torus() does not support spindle or self intersecting tori")
	return 4 * pow(_a				,      2) * torus_radius * tube_radius

def 			lowerCamelCase__			(       _a				,      _a):
	if length < 0 or width < 0:
		raise ValueError("area_rectangle() only accepts non-negative values")
	return length * width

def 			lowerCamelCase__			(       _a):
	if side_length < 0:
		raise ValueError("area_square() only accepts non-negative values")
	return side_length**2

def 			lowerCamelCase__			(       _a				,      _a):
	if base < 0 or height < 0:
		raise ValueError("area_triangle() only accepts non-negative values")
	return (base * height) / 2

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if sidea < 0 or sidea < 0 or sidea < 0:
		raise ValueError("area_triangle_three_sides() only accepts non-negative values")
	elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
		raise ValueError("Given three sides do not form a triangle")
	SCREAMING_SNAKE_CASE :   List[str]					  =							(sidea + sidea + sidea) / 2
	SCREAMING_SNAKE_CASE :   Optional[int]					  =							sqrt(
	    semi_perimeter
	    * (semi_perimeter - sidea)
	    * (semi_perimeter - sidea)
	    * (semi_perimeter - sidea))
	return area

def 			lowerCamelCase__			(       _a				,      _a):
	if base < 0 or height < 0:
		raise ValueError("area_parallelogram() only accepts non-negative values")
	return base * height

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	if basea < 0 or basea < 0 or height < 0:
		raise ValueError("area_trapezium() only accepts non-negative values")
	return 1 / 2 * (basea + basea) * height

def 			lowerCamelCase__			(       _a):
	if radius < 0:
		raise ValueError("area_circle() only accepts non-negative values")
	return pi * radius**2

def 			lowerCamelCase__			(       _a				,      _a):
	if radius_x < 0 or radius_y < 0:
		raise ValueError("area_ellipse() only accepts non-negative values")
	return pi * radius_x * radius_y

def 			lowerCamelCase__			(       _a				,      _a):
	if diagonal_a < 0 or diagonal_a < 0:
		raise ValueError("area_rhombus() only accepts non-negative values")
	return 1 / 2 * diagonal_a * diagonal_a

def 			lowerCamelCase__			(       _a				,      _a):
	if not isinstance(_a				,      _a) or sides < 3:
		raise ValueError(
		    "area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides")
	elif length < 0:
		raise ValueError(
		    "area_reg_polygon() only accepts non-negative values as \
length of a side")
	return (sides * length**2) / (4 * tan(pi / sides))
	return (sides * length**2) / (4 * tan(pi / sides))


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

			print('[DEMO] Areas of various geometric shapes: \n')
			print(F'''Rectangle: {area_rectangle(10, 20) = }''')
			print(F'''Square: {area_square(10) = }''')
			print(F'''Triangle: {area_triangle(10, 10) = }''')
			print(F'''Triangle: {area_triangle_three_sides(5, 12, 13) = }''')
			print(F'''Parallelogram: {area_parallelogram(10, 20) = }''')
			print(F'''Rhombus: {area_rhombus(10, 20) = }''')
			print(F'''Trapezium: {area_trapezium(10, 20, 30) = }''')
			print(F'''Circle: {area_circle(20) = }''')
			print(F'''Ellipse: {area_ellipse(10, 20) = }''')
			print('\nSurface Areas of various geometric shapes: \n')
			print(F'''Cube: {surface_area_cube(20) = }''')
			print(F'''Cuboid: {surface_area_cuboid(10, 20, 30) = }''')
			print(F'''Sphere: {surface_area_sphere(20) = }''')
			print(F'''Hemisphere: {surface_area_hemisphere(20) = }''')
			print(F'''Cone: {surface_area_cone(10, 20) = }''')
			print(F'''Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }''')
			print(F'''Cylinder: {surface_area_cylinder(10, 20) = }''')
			print(F'''Torus: {surface_area_torus(20, 10) = }''')
			print(F'''Equilateral Triangle: {area_reg_polygon(3, 10) = }''')
			print(F'''Square: {area_reg_polygon(4, 10) = }''')
			print(F'''Reqular Pentagon: {area_reg_polygon(5, 10) = }''')