

from __future__ import annotations

import unittest
import warnings

from transformers import AutoTokenizer, MarianConfig, MarianTokenizer, TranslationPipeline, 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, TFMarianModel, TFMarianMTModel






@require_tf
class     _UpperCAmelCase			:
			__a :       int									=							MarianConfig
			__a :       List[Any]									=							{}
			__a :       Optional[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      ,		)    ->    List[str]:






				'''simple docstring'''







				_UpperCAmelCase    :							Union[str, Any]									=					parent
				_UpperCAmelCase    :							Tuple									=					batch_size
				_UpperCAmelCase    :							Union[str, Any]									=					seq_length
				_UpperCAmelCase    :							Dict									=					is_training
				_UpperCAmelCase    :							Union[str, Any]									=					use_labels
				_UpperCAmelCase    :							Tuple									=					vocab_size
				_UpperCAmelCase    :							List[Any]									=					hidden_size
				_UpperCAmelCase    :							Dict									=					num_hidden_layers
				_UpperCAmelCase    :							List[Any]									=					num_attention_heads
				_UpperCAmelCase    :							Dict									=					intermediate_size

				_UpperCAmelCase    :							Optional[int]									=					hidden_dropout_prob
				_UpperCAmelCase    :							int									=					attention_probs_dropout_prob
				_UpperCAmelCase    :							Optional[Any]									=					max_position_embeddings
				_UpperCAmelCase    :							Union[str, Any]									=					eos_token_id
				_UpperCAmelCase    :							int									=					pad_token_id
				_UpperCAmelCase    :							Tuple									=					bos_token_id
			def 							__snake_case (		self     )    ->    Optional[int]:






				'''simple docstring'''







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

				_UpperCAmelCase    :							Union[str, Any]									=					ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size     )

				_UpperCAmelCase    :							Optional[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      ,		)
				_UpperCAmelCase    :							Any									=					prepare_marian_inputs_dict(_A      ,		_A      ,		_A     )
				return config, inputs_dict
			def 							__snake_case (		self      ,		_A      ,		_A     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							str									=					TFMarianModel(config=_A     ).get_decoder()
				_UpperCAmelCase    :							str									=					inputs_dict["""input_ids"""]

				_UpperCAmelCase    :							Optional[int]									=					input_ids[:1, :]
				_UpperCAmelCase    :							Optional[Any]									=					inputs_dict["""attention_mask"""][:1, :]
				_UpperCAmelCase    :							Union[str, Any]									=					inputs_dict["""head_mask"""]
				_UpperCAmelCase    :							int									=					1

				# first forward pass
				_UpperCAmelCase    :							Tuple									=					model(_A      ,		attention_mask=_A      ,		head_mask=_A      ,		use_cache=_A     )

				_UpperCAmelCase						,   _UpperCAmelCase    :							Optional[int]									=					outputs.to_tuple()

				# create hypothetical next token and extent to next_input_ids
				_UpperCAmelCase    :							List[str]									=					ids_tensor((self.batch_size, 3)      ,		config.vocab_size     )
				_UpperCAmelCase    :							int									=					tf.cast(ids_tensor((self.batch_size, 3)      ,		2     )      ,		tf.inta     )

				# append to next input_ids and
				_UpperCAmelCase    :							List[str]									=					tf.concat([input_ids, next_tokens]      ,		axis=-1     )
				_UpperCAmelCase    :							Optional[Any]									=					tf.concat([attention_mask, next_attn_mask]      ,		axis=-1     )

				_UpperCAmelCase    :							Union[str, Any]									=					model(_A      ,		attention_mask=_A     )[0]
				_UpperCAmelCase    :							Optional[int]									=					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
				_UpperCAmelCase    :							Dict									=					int(ids_tensor((1,)      ,		output_from_past.shape[-1]     )     )
				_UpperCAmelCase    :							Optional[Any]									=					output_from_no_past[:, -3:, random_slice_idx]
				_UpperCAmelCase    :							Dict									=					output_from_past[:, :, random_slice_idx]

				# test that outputs are equal for slice
				tf.debugging.assert_near(_A      ,		_A      ,		rtol=1e-3     )
def       UpperCamelCase					(			_lowerCAmelCase     :						Dict,  _lowerCAmelCase     :						Optional[Any],  _lowerCAmelCase     :						List[Any],  _lowerCAmelCase     :						Dict=None,  _lowerCAmelCase     :						Tuple=None,  _lowerCAmelCase     :						int=None,  _lowerCAmelCase     :						List[str]=None,  _lowerCAmelCase     :						List[Any]=None,  )				->			Any:







	if attention_mask is None:
		_UpperCAmelCase    :							Optional[int]									=					tf.cast(tf.math.not_equal(lowercase__,  config.pad_token_id ),  tf.inta )
	if decoder_attention_mask is None:
		_UpperCAmelCase    :							Optional[Any]									=					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:
		_UpperCAmelCase    :							Any									=					tf.ones((config.encoder_layers, config.encoder_attention_heads) )
	if decoder_head_mask is None:
		_UpperCAmelCase    :							Union[str, Any]									=					tf.ones((config.decoder_layers, config.decoder_attention_heads) )
	if cross_attn_head_mask is None:
		_UpperCAmelCase    :							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			(		A_    ,     A_    ,     unittest.TestCase):
			__a :       str									=							(TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
			__a :       Union[str, Any]									=							(TFMarianMTModel,) if is_tf_available() else ()
			__a :       List[str]									=							(
			    {
			        '''conversational''': TFMarianMTModel,
			        '''feature-extraction''': TFMarianModel,
			        '''summarization''': TFMarianMTModel,
			        '''text2text-generation''': TFMarianMTModel,
			        '''translation''': TFMarianMTModel,
			    }
			    if is_tf_available()
			    else {}
			)
			__a :       str									=							True
			__a :       List[str]									=							False
			__a :       Optional[int]									=							False
			def 							__snake_case (		self     )    ->    int:






				'''simple docstring'''







				_UpperCAmelCase    :							Any									=					TFMarianModelTester(self     )
				_UpperCAmelCase    :							Tuple									=					ConfigTester(self      ,		config_class=_A     )
			def 							__snake_case (		self     )    ->    Dict:






				'''simple docstring'''







				self.config_tester.run_common_tests()
			def 							__snake_case (		self     )    ->    Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							int									=					self.model_tester.prepare_config_and_inputs_for_common()
				self.model_tester.check_decoder_model_past_large_inputs(*_A     )






@require_tf
class     _UpperCAmelCase			(		unittest.TestCase):
			__a :       Tuple									=							1_0_0_0  # show more chars for failing integration tests
			@classmethod
			def 							__snake_case (		cls     )    ->    List[str]:






				'''simple docstring'''







				_UpperCAmelCase    :							List[Any]									=					f'''Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}'''
				return cls
			@cached_property
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				return AutoTokenizer.from_pretrained(self.model_name     )
			@property
			def 							__snake_case (		self     )    ->    int:






				'''simple docstring'''







				return self.tokenizer.eos_token_id
			@cached_property
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				warnings.simplefilter("""error"""     )
				_UpperCAmelCase    :							Optional[int]									=					TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name     )
				assert isinstance(_A      ,		_A     )
				_UpperCAmelCase    :							str									=					model.config
				self.assertListEqual(c.bad_words_ids      ,		[[c.pad_token_id]]     )
				self.assertEqual(c.max_length      ,		5_12     )
				self.assertEqual(c.decoder_start_token_id      ,		c.pad_token_id     )
				return model
			def 							__snake_case (		self      ,		**_A     )    ->    Optional[Any]:






				'''simple docstring'''







				_UpperCAmelCase    :							str									=					self.translate_src_text(**_A     )
				self.assertListEqual(self.expected_text      ,		_A     )
			def 							__snake_case (		self      ,		**_A     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							Optional[int]									=					self.tokenizer(self.src_text      ,		**_A      ,		padding=_A      ,		return_tensors="""tf"""     )
				_UpperCAmelCase    :							str									=					self.model.generate(
				    model_inputs.input_ids      ,		attention_mask=model_inputs.attention_mask      ,		num_beams=2      ,		max_length=1_28     )
				_UpperCAmelCase    :							List[Any]									=					self.tokenizer.batch_decode(generated_ids.numpy()      ,		skip_special_tokens=_A     )
				return generated_words






@require_sentencepiece
@require_tokenizers
@require_tf
class     _UpperCAmelCase			(		A_):
			__a :       Union[str, Any]									=							'''mt'''
			__a :       Tuple									=							'''en'''
			__a :       Optional[Any]									=							['''Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.''']
			__a :       List[str]									=							['''Touching gently, Jesus healed a man who was affected by the sad disease of leprosy.''']
			@unittest.skip("""Skipping until #12647 is resolved."""     )
			@slow
			def 							__snake_case (		self     )    ->    List[Any]:






				'''simple docstring'''







				self._assert_generated_batch_equal_expected()






@require_sentencepiece
@require_tokenizers
@require_tf
class     _UpperCAmelCase			(		A_):
			__a :       List[Any]									=							'''en'''
			__a :       str									=							'''zh'''
			__a :       Dict									=							['''My name is Wolfgang and I live in Berlin''']
			__a :       Optional[int]									=							['''我叫沃尔夫冈 我住在柏林''']
			@unittest.skip("""Skipping until #12647 is resolved."""     )
			@slow
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				self._assert_generated_batch_equal_expected()






@require_sentencepiece
@require_tokenizers
@require_tf
class     _UpperCAmelCase			(		A_):
			__a :       Tuple									=							'''en'''
			__a :       List[Any]									=							'''ROMANCE'''
			__a :       int									=							[
			    '''>>fr<< Don\'t spend so much time watching TV.''',
			    '''>>pt<< Your message has been sent.''',
			    '''>>es<< He\'s two years older than me.''',
			]
			__a :       str									=							[
			    '''Ne passez pas autant de temps à regarder la télé.''',
			    '''A sua mensagem foi enviada.''',
			    '''Es dos años más viejo que yo.''',
			]
			@unittest.skip("""Skipping until #12647 is resolved."""     )
			@slow
			def 							__snake_case (		self     )    ->    List[Any]:






				'''simple docstring'''







				self._assert_generated_batch_equal_expected()
			@unittest.skip("""Skipping until #12647 is resolved."""     )
			@slow
			def 							__snake_case (		self     )    ->    Tuple:






				'''simple docstring'''







				_UpperCAmelCase    :							str									=					TranslationPipeline(self.model      ,		self.tokenizer      ,		framework="""tf"""     )
				_UpperCAmelCase    :							List[Any]									=					pipeline(self.src_text     )
				self.assertEqual(self.expected_text      ,		[x["""translation_text"""] for x in output]     )








"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase__				:  Optional[int]													=  {'''configuration_t5''': ['''T5_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''T5Config''', '''T5OnnxConfig''']}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  Dict													=  ['''T5Tokenizer''']

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  List[str]													=  ['''T5TokenizerFast''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  Optional[Any]													=  [
						    '''T5_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''T5EncoderModel''',
						    '''T5ForConditionalGeneration''',
						    '''T5Model''',
						    '''T5PreTrainedModel''',
						    '''load_tf_weights_in_t5''',
						    '''T5ForQuestionAnswering''',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  int													=  [
						    '''TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''TFT5EncoderModel''',
						    '''TFT5ForConditionalGeneration''',
						    '''TFT5Model''',
						    '''TFT5PreTrainedModel''',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__				:  Any													=  [
						    '''FlaxT5EncoderModel''',
						    '''FlaxT5ForConditionalGeneration''',
						    '''FlaxT5Model''',
						    '''FlaxT5PreTrainedModel''',
						]


if TYPE_CHECKING:
						from .configuration_ta import T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TaConfig, TaOnnxConfig

						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_ta import TaTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_ta_fast import TaTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_ta import (
												    T5_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TaEncoderModel,
												    TaForConditionalGeneration,
												    TaForQuestionAnswering,
												    TaModel,
												    TaPreTrainedModel,
												    load_tf_weights_in_ta,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_ta import (
												    TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFTaEncoderModel,
												    TFTaForConditionalGeneration,
												    TFTaModel,
												    TFTaPreTrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_ta import (
												    FlaxTaEncoderModel,
												    FlaxTaForConditionalGeneration,
												    FlaxTaModel,
												    FlaxTaPreTrainedModel,
												)


else:
						import sys

						lowerCamelCase__				:  Dict													=  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





