



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 			__A							(       self		):
							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-1_2		)
							tf.debugging.assert_equal(UpperCAmelCase__			,	UpperCAmelCase__		)






@require_tf
class      UpperCamelCase    (						unittest.TestCase       ,    _UpperCAmelCase     ):
	# setting framework_dependent_parameters needs to be gated, just like its contents' imports
	if is_tf_available():
		lowerCAmelCase	:   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
							A__							=       TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
							A__							=       2
							A__							=       2






							class      UpperCamelCase    (						tf.Module     ):



								def __init__(       self			,	UpperCAmelCase__		):
														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__		):
														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		):
							# TF-only test: tf.saved_model export
							A__							=       TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"		)
							A__							=       1
							A__							=       2






							class      UpperCamelCase    (						tf.Module     ):



								def __init__(       self			,	UpperCAmelCase__		):
														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__		):
														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		):
							# 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      UpperCamelCase    (						tf.keras.layers.Layer     ):



														def __init__(       self		):
																				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__		):
																				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		):
							# 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		):
							# 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      UpperCamelCase    (						_UpperCAmelCase     ):



								def 			__A							(       self			,	UpperCAmelCase__			,	UpperCAmelCase__=None			,	**UpperCAmelCase__		):
														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      UpperCamelCase    (						bart_model.model.encoder.__class__     ):



								def 			__A							(       self			,	UpperCAmelCase__			,	**UpperCAmelCase__		):
														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"		)










import os
import zipfile

import requests
from get_ci_error_statistics import download_artifact, get_artifacts_links
def  UpperCamelCase						(       _A			:				List[Any]			,							_A			:				List[str]=7    )->       Optional[Any]:





						"""simple docstring"""





						A__							=       None
						if token is not None:
												A__							=       {"Accept": "application/vnd.github+json", "Authorization": f"""Bearer {token}"""}

						# The id of a workflow (not of a workflow run)
						A__							=       "636036"

						A__							=       f"""https://api.github.com/repos/huggingface/transformers/actions/workflows/{workflow_id}/runs"""
						# On `main` branch + event being `schedule` + not returning PRs + only `num_runs` results
						url += f"""?branch=main&event=schedule&exclude_pull_requests=true&per_page={num_runs}"""

						A__							=       requests.get(_A			,							headers=_A    ).json()

						return result["workflow_runs"]
def  UpperCamelCase						(       _A			:				str    )->       Dict:





						"""simple docstring"""





						A__							=       get_daily_ci_runs(_A    )
						A__							=       None
						for workflow_run in workflow_runs:
												if workflow_run["status"] == "completed":
																		A__							=       workflow_run["id"]
																		break

						return workflow_run_id
def  UpperCamelCase						(       _A			:				int			,							_A			:				List[str]			,							_A			:				str    )->       Any:





						"""simple docstring"""





						A__							=       get_last_daily_ci_runs(_A    )
						if workflow_run_id is not None:
												A__							=       get_artifacts_links(worflow_run_id=_A			,							token=_A    )
												for artifact_name in artifact_names:
																		if artifact_name in artifacts_links:
																								A__							=       artifacts_links[artifact_name]
																								download_artifact(
																								    artifact_name=_A			,							artifact_url=_A			,							output_dir=_A			,							token=_A    )
def  UpperCamelCase						(       _A			:				Optional[Any]			,							_A			:				Any			,							_A			:				List[Any]    )->       Optional[int]:





						"""simple docstring"""





						get_last_daily_ci_artifacts(_A			,							_A			,							_A    )

						A__							=       {}
						for artifact_name in artifact_names:
												A__							=       os.path.join(_A			,							f"""{artifact_name}.zip"""    )
												if os.path.isfile(_A    ):
																		A__							=       {}
																		with zipfile.ZipFile(_A    ) as z:
																								for filename in z.namelist():
																														if not os.path.isdir(_A    ):
																																				# read the file
																																				with z.open(_A    ) as f:
																																										A__							=       f.read().decode("UTF-8"    )

						return results





