



'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import AutoTokenizer, MBartConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

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 TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel






@require_tf
class 						_UpperCamelCase  :


			'''simple docstring'''

			_A      :		Union[str, Any]			    =		MBartConfig
			_A      :		Optional[int]			    =		{}
			_A      :		str			    =		'''gelu'''

			def __init__(							self     : Optional[Any]							,     lowerCAmelCase__     : Optional[Any]							,     lowerCAmelCase__     : str=1_3							,     lowerCAmelCase__     : str=7							,     lowerCAmelCase__     : Optional[int]=True							,     lowerCAmelCase__     : List[str]=False							,     lowerCAmelCase__     : Any=9_9							,     lowerCAmelCase__     : Tuple=3_2							,     lowerCAmelCase__     : Tuple=2							,     lowerCAmelCase__     : List[str]=4							,     lowerCAmelCase__     : Any=3_7							,     lowerCAmelCase__     : str=0.1							,     lowerCAmelCase__     : str=0.1							,     lowerCAmelCase__     : Union[str, Any]=2_0							,     lowerCAmelCase__     : Tuple=2							,     lowerCAmelCase__     : Optional[int]=1							,     lowerCAmelCase__     : Optional[int]=0							,     ):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		int           =		parent
					__SCREAMING_SNAKE_CASE       :		List[str]           =		batch_size
					__SCREAMING_SNAKE_CASE       :		List[Any]           =		seq_length
					__SCREAMING_SNAKE_CASE       :		Dict           =		is_training
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		use_labels
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		vocab_size
					__SCREAMING_SNAKE_CASE       :		Any           =		hidden_size
					__SCREAMING_SNAKE_CASE       :		List[Any]           =		num_hidden_layers
					__SCREAMING_SNAKE_CASE       :		Any           =		num_attention_heads
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		intermediate_size
					__SCREAMING_SNAKE_CASE       :		List[Any]           =		hidden_dropout_prob
					__SCREAMING_SNAKE_CASE       :		List[str]           =		attention_probs_dropout_prob
					__SCREAMING_SNAKE_CASE       :		int           =		max_position_embeddings
					__SCREAMING_SNAKE_CASE       :		Tuple           =		eos_token_id
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		pad_token_id
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		bos_token_id

			def UpperCamelCase__					(							self     : Optional[int]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[str]           =		ids_tensor([self.batch_size, self.seq_length - 1]							,     self.vocab_size						)
					__SCREAMING_SNAKE_CASE       :		List[Any]           =		tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size						)							,     1						)
					__SCREAMING_SNAKE_CASE       :		Tuple           =		tf.concat([input_ids, eos_tensor]							,     axis=1						)

					__SCREAMING_SNAKE_CASE       :		Any           =		ids_tensor([self.batch_size, self.seq_length]							,     self.vocab_size						)

					__SCREAMING_SNAKE_CASE       :		Any           =		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							,     **self.config_updates							,     )
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		prepare_mbart_inputs_dict(lowerCAmelCase__							,     lowerCAmelCase__							,     lowerCAmelCase__						)
					return config, inputs_dict



			def UpperCamelCase__					(							self     : Tuple							,     lowerCAmelCase__     : int							,     lowerCAmelCase__     : Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		str           =		TFMBartModel(config=lowerCAmelCase__						).get_decoder()
					__SCREAMING_SNAKE_CASE       :		Tuple           =		inputs_dict["""input_ids"""]

					__SCREAMING_SNAKE_CASE       :		Dict           =		input_ids[:1, :]
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		inputs_dict["""attention_mask"""][:1, :]
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		inputs_dict["""head_mask"""]
					__SCREAMING_SNAKE_CASE       :		Optional[int]           =		1

					# first forward pass
					__SCREAMING_SNAKE_CASE       :		str           =		model(lowerCAmelCase__							,     attention_mask=lowerCAmelCase__							,     head_mask=lowerCAmelCase__							,     use_cache=lowerCAmelCase__						)

					__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		outputs.to_tuple()
					__SCREAMING_SNAKE_CASE       :		Dict           =		past_key_values[1]


def 				lowerCAmelCase_   (	_lowerCamelCase:   Any       ,      _lowerCamelCase:   Optional[int]       ,      _lowerCamelCase:   List[Any]       ,      _lowerCamelCase:   Dict=None       ,      _lowerCamelCase:   List[Any]=None       ,      _lowerCamelCase:   Optional[int]=None       ,      _lowerCamelCase:   Dict=None       ,      _lowerCamelCase:   Dict=None       ,      ):
		if attention_mask is None:
				__SCREAMING_SNAKE_CASE       :		Tuple           =		tf.cast(tf.math.not_equal(_lowerCamelCase       ,      config.pad_token_id					)       ,      tf.inta					)
		if decoder_attention_mask is None:
				__SCREAMING_SNAKE_CASE       :		str           =		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:
				__SCREAMING_SNAKE_CASE       :		Tuple           =		tf.ones((config.encoder_layers, config.encoder_attention_heads)					)
		if decoder_head_mask is None:
				__SCREAMING_SNAKE_CASE       :		Any           =		tf.ones((config.decoder_layers, config.decoder_attention_heads)					)
		if cross_attn_head_mask is None:
				__SCREAMING_SNAKE_CASE       :		List[Any]           =		tf.ones((config.decoder_layers, config.decoder_attention_heads)					)
		return {
		    "input_ids": input_ids,
		    "decoder_input_ids": decoder_input_ids,
		    "attention_mask": attention_mask,
		    "decoder_attention_mask": decoder_attention_mask,
		    "head_mask": head_mask,
		    "decoder_head_mask": decoder_head_mask,
		    "cross_attn_head_mask": cross_attn_head_mask,
		}






@require_tf
class 						_UpperCamelCase  (							lowerCamelCase__    ,					lowerCamelCase__    ,					unittest.TestCase    ):


			'''simple docstring'''

			_A      :		List[Any]			    =		(TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else ()
			_A      :		List[Any]			    =		(TFMBartForConditionalGeneration,) if is_tf_available() else ()
			_A      :		Union[str, Any]			    =		(
			    {
			        '''conversational''': TFMBartForConditionalGeneration,
			        '''feature-extraction''': TFMBartModel,
			        '''summarization''': TFMBartForConditionalGeneration,
			        '''text2text-generation''': TFMBartForConditionalGeneration,
			        '''translation''': TFMBartForConditionalGeneration,
			    }
			    if is_tf_available()
			    else {}
			)
			_A      :		str			    =		True
			_A      :		Tuple			    =		False
			_A      :		Dict			    =		False

			def UpperCamelCase__					(							self     : Optional[Any]							,     lowerCAmelCase__     : str							,     lowerCAmelCase__     : Tuple							,     lowerCAmelCase__     : List[str]							,     lowerCAmelCase__     : List[Any]							,     lowerCAmelCase__     : Dict						):





					"""simple docstring"""






					if pipeline_test_casse_name != "FeatureExtractionPipelineTests":
							# Exception encountered when calling layer '...'
							return True

					return False

			def UpperCamelCase__					(							self     : Optional[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Union[str, Any]           =		TFMBartModelTester(self						)
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		ConfigTester(self							,     config_class=lowerCAmelCase__						)

			def UpperCamelCase__					(							self     : List[Any]						):





					"""simple docstring"""






					self.config_tester.run_common_tests()



			def UpperCamelCase__					(							self     : str						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Tuple           =		self.model_tester.prepare_config_and_inputs_for_common()
					self.model_tester.check_decoder_model_past_large_inputs(*lowerCAmelCase__						)






@require_sentencepiece
@require_tokenizers
@require_tf
class 						_UpperCamelCase  (							unittest.TestCase    ):


			'''simple docstring'''

			_A      :		str			    =		[
			    ''' UN Chief Says There Is No Military Solution in Syria''',
			]
			_A      :		Optional[int]			    =		[
			    '''Şeful ONU declară că nu există o soluţie militară în Siria''',
			]
			_A      :		Tuple			    =		'''facebook/mbart-large-en-ro'''

			@cached_property
			def UpperCamelCase__					(							self     : Dict						):





					"""simple docstring"""






					return AutoTokenizer.from_pretrained(self.model_name						)

			@cached_property
			def UpperCamelCase__					(							self     : Dict						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[str]           =		TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name						)
					return model

			def UpperCamelCase__					(							self     : List[Any]							,     **lowerCAmelCase__     : Optional[Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		List[str]           =		self.translate_src_text(**lowerCAmelCase__						)
					self.assertListEqual(self.expected_text							,     lowerCAmelCase__						)

			def UpperCamelCase__					(							self     : Optional[int]							,     **lowerCAmelCase__     : Union[str, Any]						):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE       :		Dict           =		self.tokenizer(self.src_text							,     **lowerCAmelCase__							,     return_tensors="""tf"""						)
					__SCREAMING_SNAKE_CASE       :		str           =		self.model.generate(
					    model_inputs.input_ids							,     attention_mask=model_inputs.attention_mask							,     num_beams=2						)
					__SCREAMING_SNAKE_CASE       :		Optional[Any]           =		self.tokenizer.batch_decode(lowerCAmelCase__							,     skip_special_tokens=lowerCAmelCase__						)
					return generated_words



			@slow
			def UpperCamelCase__					(							self     : int						):





					"""simple docstring"""






					self._assert_generated_batch_equal_expected()




'''simple docstring'''




def 				lowerCAmelCase_   (	_lowerCamelCase:   float       ,      _lowerCamelCase:   list[float]					):
		if discount_rate < 0:
				raise ValueError("""Discount rate cannot be negative"""					)
		if not cash_flows:
				raise ValueError("""Cash flows list cannot be empty"""					)
		__SCREAMING_SNAKE_CASE       :		List[str]           =		sum(
		    cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(_lowerCamelCase					)					)
		return round(_lowerCamelCase       ,      ndigits=2					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()