






"""simple docstring"""






from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import TFLEDForConditionalGeneration, TFLEDModel





@require_tf
class       snake_case_       :



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							Optional[Any]   			=					LEDConfig
	SCREAMING_SNAKE_CASE_:							Optional[int]   			=					{}
	SCREAMING_SNAKE_CASE_:							int   			=					"""gelu"""


	def __init__(      self  ,					__a  ,					__a=13  ,					__a=7  ,					__a=True  ,					__a=False  ,					__a=99  ,					__a=32  ,					__a=2  ,					__a=4  ,					__a=37  ,					__a=0.1  ,					__a=0.1  ,					__a=20  ,					__a=2  ,					__a=1  ,					__a=0  ,					__a=4  ,					):


					"""simple docstring"""

					A__							 =       parent
					A__							 =       batch_size
					A__							 =       seq_length
					A__							 =       is_training
					A__							 =       use_labels
					A__							 =       vocab_size
					A__							 =       hidden_size
					A__							 =       num_hidden_layers
					A__							 =       num_attention_heads
					A__							 =       intermediate_size

					A__							 =       hidden_dropout_prob
					A__							 =       attention_probs_dropout_prob
					A__							 =       max_position_embeddings
					A__							 =       eos_token_id
					A__							 =       pad_token_id
					A__							 =       bos_token_id
					A__							 =       attention_window

					# `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
					# [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
					# returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
					# because its local attention only attends to `self.attention_window` and one before and one after
					A__							 =       self.attention_window + 2

					# because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
					# the `test_attention_outputs` and `test_hidden_states_output` tests
					A__							 =       (
					    self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
					)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       ids_tensor([self.batch_size, self.seq_length - 1]  ,					self.vocab_size						)
					A__							 =       tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size						)  ,					1						)
					A__							 =       tf.concat([input_ids, eos_tensor]  ,					axis=1						)

					A__							 =       ids_tensor([self.batch_size, self.seq_length]  ,					self.vocab_size						)

					A__							 =       self.config_cls(
					    vocab_size=self.vocab_size  ,					d_model=self.hidden_size  ,					encoder_layers=self.num_hidden_layers  ,					decoder_layers=self.num_hidden_layers  ,					encoder_attention_heads=self.num_attention_heads  ,					decoder_attention_heads=self.num_attention_heads  ,					encoder_ffn_dim=self.intermediate_size  ,					decoder_ffn_dim=self.intermediate_size  ,					dropout=self.hidden_dropout_prob  ,					attention_dropout=self.attention_probs_dropout_prob  ,					max_position_embeddings=self.max_position_embeddings  ,					eos_token_ids=[2]  ,					bos_token_id=self.bos_token_id  ,					pad_token_id=self.pad_token_id  ,					decoder_start_token_id=self.pad_token_id  ,					attention_window=self.attention_window  ,					**self.config_updates  ,					)
					A__							 =       prepare_led_inputs_dict(__a  ,					__a  ,					__a						)
					A__							 =       tf.concat(
					    [tf.zeros_like(__a						)[:, :-1], tf.ones_like(__a						)[:, -1:]]  ,					axis=-1  ,					)
					A__							 =       global_attention_mask
					return config, inputs_dict






	def       _UpperCAmelCase						(      self  ,					__a  ,					__a						):


					"""simple docstring"""

					A__							 =       TFLEDModel(config=__a						).get_decoder()
					A__							 =       inputs_dict['input_ids']

					A__							 =       input_ids[:1, :]
					A__							 =       inputs_dict['attention_mask'][:1, :]
					A__							 =       1

					# first forward pass
					A__							 =       model(__a  ,					attention_mask=__a  ,					use_cache=__a						)

					A__ ,			A__							 =       outputs.to_tuple()

					# create hypothetical next token and extent to next_input_ids
					A__							 =       ids_tensor((self.batch_size, 3)  ,					config.vocab_size						)
					A__							 =       tf.cast(ids_tensor((self.batch_size, 3)  ,					2						)  ,					tf.inta						)

					# append to next input_ids and
					A__							 =       tf.concat([input_ids, next_tokens]  ,					axis=-1						)
					A__							 =       tf.concat([attention_mask, next_attn_mask]  ,					axis=-1						)

					A__							 =       model(__a  ,					attention_mask=__a						)[0]
					A__							 =       model(__a  ,					attention_mask=__a  ,					past_key_values=__a						)[0]

					self.parent.assertEqual(next_tokens.shape[1]  ,					output_from_past.shape[1]						)

					# select random slice
					A__							 =       int(ids_tensor((1,)  ,					output_from_past.shape[-1]						)						)
					A__							 =       output_from_no_past[:, -3:, random_slice_idx]
					A__							 =       output_from_past[:, :, random_slice_idx]

					# test that outputs are equal for slice
					tf.debugging.assert_near(__a  ,					__a  ,					rtol=1E-3						)





def  __lowerCamelCase					(					lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__=None       ,lowerCAmelCase__=None       ,lowerCAmelCase__=None       ,lowerCAmelCase__=None       ,):
				if attention_mask is None:
								A__							 =       tf.cast(tf.math.not_equal(lowerCAmelCase__       ,config.pad_token_id				)       ,tf.inta				)
				if decoder_attention_mask is None:
								A__							 =       tf.concat(
								    [
								        tf.ones(decoder_input_ids[:, :1].shape       ,dtype=tf.inta				),
								        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]       ,config.pad_token_id				)       ,tf.inta				),
								    ]       ,axis=-1       ,)
				if head_mask is None:
								A__							 =       tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
				if decoder_head_mask is None:
								A__							 =       tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
				return {
				    "input_ids": input_ids,
				    "attention_mask": attention_mask,
				    "decoder_input_ids": decoder_input_ids,
				    "decoder_attention_mask": decoder_attention_mask,
				    "head_mask": head_mask,
				    "decoder_head_mask": decoder_head_mask,
				}





@require_tf
class       snake_case_       (    _lowerCamelCase    ,							_lowerCamelCase    ,							unittest.TestCase       ):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							int   			=					(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
	SCREAMING_SNAKE_CASE_:							Tuple   			=					(TFLEDForConditionalGeneration,) if is_tf_available() else ()
	SCREAMING_SNAKE_CASE_:							Dict   			=					(
	    {
	        """conversational""": TFLEDForConditionalGeneration,
	        """feature-extraction""": TFLEDModel,
	        """summarization""": TFLEDForConditionalGeneration,
	        """text2text-generation""": TFLEDForConditionalGeneration,
	        """translation""": TFLEDForConditionalGeneration,
	    }
	    if is_tf_available()
	    else {}
	)
	SCREAMING_SNAKE_CASE_:							str   			=					True
	SCREAMING_SNAKE_CASE_:							Optional[Any]   			=					False
	SCREAMING_SNAKE_CASE_:							List[Any]   			=					False
	SCREAMING_SNAKE_CASE_:							List[Any]   			=					False


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       TFLEDModelTester(self						)
					A__							 =       ConfigTester(self  ,					config_class=__a						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					self.config_tester.run_common_tests()


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs_for_common()
					self.model_tester.check_decoder_model_past_large_inputs(*__a						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__ ,			A__							 =       self.model_tester.prepare_config_and_inputs_for_common()
					A__							 =       tf.zeros_like(inputs_dict['attention_mask']						)
					A__							 =       2
					A__							 =       tf.where(
					    tf.range(self.model_tester.seq_length						)[None, :] < num_global_attn_indices  ,					1  ,					inputs_dict['global_attention_mask']  ,					)

					A__							 =       True
					A__							 =       self.model_tester.seq_length
					A__							 =       self.model_tester.encoder_seq_length

					def check_decoder_attentions_output(__a						):
									A__							 =       outputs.decoder_attentions
									self.assertEqual(len(__a						)  ,					self.model_tester.num_hidden_layers						)
									self.assertListEqual(
									    list(decoder_attentions[0].shape[-3:]						)  ,					[self.model_tester.num_attention_heads, seq_length, seq_length]  ,					)

					def check_encoder_attentions_output(__a						):
									A__							 =       [t.numpy() for t in outputs.encoder_attentions]
									A__							 =       [t.numpy() for t in outputs.encoder_global_attentions]
									self.assertEqual(len(__a						)  ,					self.model_tester.num_hidden_layers						)
									self.assertEqual(len(__a						)  ,					self.model_tester.num_hidden_layers						)
									self.assertListEqual(
									    list(attentions[0].shape[-3:]						)  ,					[self.model_tester.num_attention_heads, seq_length, seq_length]  ,					)
									self.assertListEqual(
									    list(global_attentions[0].shape[-3:]						)  ,					[self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]  ,					)

					for model_class in self.all_model_classes:
									A__							 =       True
									A__							 =       False
									A__							 =       False
									A__							 =       model_class(__a						)
									A__							 =       model(self._prepare_for_class(__a  ,					__a						)						)
									A__							 =       len(__a						)
									self.assertEqual(config.output_hidden_states  ,					__a						)
									check_encoder_attentions_output(__a						)

									if self.is_encoder_decoder:
													A__							 =       model_class(__a						)
													A__							 =       model(self._prepare_for_class(__a  ,					__a						)						)
													self.assertEqual(config.output_hidden_states  ,					__a						)
													check_decoder_attentions_output(__a						)

									# Check that output attentions can also be changed via the config
									del inputs_dict["output_attentions"]
									A__							 =       True
									A__							 =       model_class(__a						)
									A__							 =       model(self._prepare_for_class(__a  ,					__a						)						)
									self.assertEqual(config.output_hidden_states  ,					__a						)
									check_encoder_attentions_output(__a						)

									# Check attention is always last and order is fine
									A__							 =       True
									A__							 =       True
									A__							 =       model_class(__a						)
									A__							 =       model(self._prepare_for_class(__a  ,					__a						)						)

									self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)  ,					len(__a						)						)
									self.assertEqual(model.config.output_hidden_states  ,					__a						)
									check_encoder_attentions_output(__a						)


	@unittest.skip('LED keeps using potentially symbolic tensors in conditionals and breaks tracing.'						)
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					pass






	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					pass





def  __lowerCamelCase					(					lowerCAmelCase__				):
				return tf.constant(lowerCAmelCase__       ,dtype=tf.intaa				)


SCREAMING_SNAKE_CASE						:						Tuple					   =       1e-4







@slow
@require_tf
class       snake_case_       (    unittest.TestCase       ):



	"""simple docstring"""

	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       TFLEDForConditionalGeneration.from_pretrained('allenai/led-base-16384'						).led

					# change to intended input here
					A__							 =       _long_tensor([512 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]						)
					A__							 =       _long_tensor([128 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]						)
					A__							 =       prepare_led_inputs_dict(model.config  ,					__a  ,					__a						)
					A__							 =       model(**__a						)[0]
					A__							 =       (1, 1024, 768)
					self.assertEqual(output.shape  ,					__a						)
					# change to expected output here
					A__							 =       tf.convert_to_tensor(
					    [[2.3050, 2.8279, 0.6531], [-1.8457, -0.1455, -3.5661], [-1.0186, 0.4586, -2.2043]]  ,					)
					tf.debugging.assert_near(output[:, :3, :3]  ,					__a  ,					atol=1E-3						)






	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       TFLEDForConditionalGeneration.from_pretrained('allenai/led-base-16384'						)

					# change to intended input here
					A__							 =       _long_tensor([512 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]						)
					A__							 =       _long_tensor([128 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]						)
					A__							 =       prepare_led_inputs_dict(model.config  ,					__a  ,					__a						)
					A__							 =       model(**__a						)[0]
					A__							 =       (1, 1024, model.config.vocab_size)
					self.assertEqual(output.shape  ,					__a						)
					# change to expected output here
					A__							 =       tf.convert_to_tensor(
					    [[33.6507, 6.4572, 16.8089], [5.8739, -2.4238, 11.2902], [-3.2139, -4.3149, 4.2783]]  ,					)
					tf.debugging.assert_near(output[:, :3, :3]  ,					__a  ,					atol=1E-3  ,					rtol=1E-3						)










"""simple docstring"""






from ...processing_utils import ProcessorMixin





class       snake_case_       (    _lowerCamelCase       ):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							List[str]   			=					"""WhisperFeatureExtractor"""
	SCREAMING_SNAKE_CASE_:							Union[str, Any]   			=					"""WhisperTokenizer"""


	def __init__(      self  ,					__a  ,					__a						):


					"""simple docstring"""

					super().__init__(__a  ,					__a						)
					A__							 =       self.feature_extractor
					A__							 =       False


	def       _UpperCAmelCase						(      self  ,					__a=None  ,					__a=None  ,					__a=True						):


					"""simple docstring"""

					return self.tokenizer.get_decoder_prompt_ids(task=__a  ,					language=__a  ,					no_timestamps=__a						)


	def __call__(      self  ,					*__a  ,					**__a						):


					"""simple docstring"""

					if self._in_target_context_manager:
									return self.current_processor(*__a  ,					**__a						)

					A__							 =       kwargs.pop('audio'  ,					__a						)
					A__							 =       kwargs.pop('sampling_rate'  ,					__a						)
					A__							 =       kwargs.pop('text'  ,					__a						)
					if len(__a						) > 0:
									A__							 =       args[0]
									A__							 =       args[1:]

					if audio is None and text is None:
									raise ValueError('You need to specify either an `audio` or `text` input to process.'						)

					if audio is not None:
									A__							 =       self.feature_extractor(__a  ,					*__a  ,					sampling_rate=__a  ,					**__a						)
					if text is not None:
									A__							 =       self.tokenizer(__a  ,					**__a						)

					if text is None:
									return inputs

					elif audio is None:
									return encodings
					else:
									A__							 =       encodings['input_ids']
									return inputs


	def       _UpperCAmelCase						(      self  ,					*__a  ,					**__a						):


					"""simple docstring"""

					return self.tokenizer.batch_decode(*__a  ,					**__a						)


	def       _UpperCAmelCase						(      self  ,					*__a  ,					**__a						):


					"""simple docstring"""

					return self.tokenizer.decode(*__a  ,					**__a						)






	def       _UpperCAmelCase						(      self  ,					__a  ,					__a="np"						):


					"""simple docstring"""

					return self.tokenizer.get_prompt_ids(__a  ,					return_tensors=__a						)


