


'''simple docstring'''


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    lowercase__  :





							'''simple docstring'''


							A_							:				int				     =  MarianConfig
							A_							:				Union[str, Any]				     =  {}
							A_							:				List[str]				     =  """gelu"""






							def __init__(   self   , __snake_case   , __snake_case=13   , __snake_case=7   , __snake_case=True   , __snake_case=False   , __snake_case=99   , __snake_case=32   , __snake_case=2   , __snake_case=4   , __snake_case=37   , __snake_case=0.1   , __snake_case=0.1   , __snake_case=20   , __snake_case=2   , __snake_case=1   , __snake_case=0   , ):
											_SCREAMING_SNAKE_CASE			:	str							=				parent
											_SCREAMING_SNAKE_CASE			:	int							=				batch_size
											_SCREAMING_SNAKE_CASE			:	str							=				seq_length
											_SCREAMING_SNAKE_CASE			:	Any							=				is_training
											_SCREAMING_SNAKE_CASE			:	str							=				use_labels
											_SCREAMING_SNAKE_CASE			:	int							=				vocab_size
											_SCREAMING_SNAKE_CASE			:	List[str]							=				hidden_size
											_SCREAMING_SNAKE_CASE			:	Dict							=				num_hidden_layers
											_SCREAMING_SNAKE_CASE			:	Any							=				num_attention_heads
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				intermediate_size

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				hidden_dropout_prob
											_SCREAMING_SNAKE_CASE			:	Any							=				attention_probs_dropout_prob
											_SCREAMING_SNAKE_CASE			:	int							=				max_position_embeddings
											_SCREAMING_SNAKE_CASE			:	str							=				eos_token_id
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				pad_token_id
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				bos_token_id






							def UpperCAmelCase_     (   self  ):
											_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			:	Any							=				tf.concat([input_ids, eos_tensor]   , axis=1  )

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

											_SCREAMING_SNAKE_CASE			:	Dict							=				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			:	Any							=				prepare_marian_inputs_dict(__snake_case   , __snake_case   , __snake_case  )
											return config, inputs_dict






							def UpperCAmelCase_     (   self   , __snake_case   , __snake_case  ):
											_SCREAMING_SNAKE_CASE			:	Any							=				TFMarianModel(config=__snake_case  ).get_decoder()
											_SCREAMING_SNAKE_CASE			:	str							=				inputs_dict["""input_ids"""]

											_SCREAMING_SNAKE_CASE			:	Dict							=				input_ids[:1, :]
											_SCREAMING_SNAKE_CASE			:	List[str]							=				inputs_dict["""attention_mask"""][:1, :]
											_SCREAMING_SNAKE_CASE			:	Tuple							=				inputs_dict["""head_mask"""]
											_SCREAMING_SNAKE_CASE			:	str							=				1

											# first forward pass
											_SCREAMING_SNAKE_CASE			:	str							=				model(__snake_case   , attention_mask=__snake_case   , head_mask=__snake_case   , use_cache=__snake_case  )

											_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE			:	List[str]							=				outputs.to_tuple()

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

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

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				model(__snake_case   , attention_mask=__snake_case  )[0]
											_SCREAMING_SNAKE_CASE			:	Any							=				model(__snake_case   , attention_mask=__snake_case   , past_key_values=__snake_case  )[0]

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

											# select random slice
											_SCREAMING_SNAKE_CASE			:	List[str]							=				int(ids_tensor((1,)   , output_from_past.shape[-1]  )  )
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				output_from_no_past[:, -3:, random_slice_idx]
											_SCREAMING_SNAKE_CASE			:	Tuple							=				output_from_past[:, :, random_slice_idx]

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







def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__=None							,				SCREAMING_SNAKE_CASE__=None							,				SCREAMING_SNAKE_CASE__=None							,				SCREAMING_SNAKE_CASE__=None							,				SCREAMING_SNAKE_CASE__=None							,				):







				"""simple docstring"""





				if attention_mask is None:
								_SCREAMING_SNAKE_CASE			:	Any							=				tf.cast(tf.math.not_equal(SCREAMING_SNAKE_CASE__							,				config.pad_token_id					)							,				tf.inta					)
				if decoder_attention_mask is None:
								_SCREAMING_SNAKE_CASE			:	Optional[int]							=				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			:	Union[str, Any]							=				tf.ones((config.decoder_layers, config.decoder_attention_heads)					)
				if cross_attn_head_mask is None:
								_SCREAMING_SNAKE_CASE			:	Optional[int]							=				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    lowercase__  (						_snake_case					,					_snake_case					,					unittest.TestCase ):





							'''simple docstring'''


							A_							:				List[str]				     =  (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
							A_							:				Any				     =  (TFMarianMTModel,) if is_tf_available() else ()
							A_							:				Union[str, Any]				     =  (
							    {
							        """conversational""": TFMarianMTModel,
							        """feature-extraction""": TFMarianModel,
							        """summarization""": TFMarianMTModel,
							        """text2text-generation""": TFMarianMTModel,
							        """translation""": TFMarianMTModel,
							    }
							    if is_tf_available()
							    else {}
							)
							A_							:				List[str]				     =  True
							A_							:				Optional[Any]				     =  False
							A_							:				Dict				     =  False






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	Any							=				TFMarianModelTester(self  )
											_SCREAMING_SNAKE_CASE			:	List[str]							=				ConfigTester(self   , config_class=__snake_case  )






							def UpperCAmelCase_     (   self  ):
											self.config_tester.run_common_tests()






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	int							=				self.model_tester.prepare_config_and_inputs_for_common()
											self.model_tester.check_decoder_model_past_large_inputs(*__snake_case  )





@require_tf
class    lowercase__  (						unittest.TestCase ):





							'''simple docstring'''


							A_							:				int				     =  1000  # show more chars for failing integration tests






							@classmethod
							def UpperCAmelCase_     (   cls  ):
											_SCREAMING_SNAKE_CASE			:	Dict							=				f"""Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"""
											return cls






							@cached_property
							def UpperCAmelCase_     (   self  ):
											return AutoTokenizer.from_pretrained(self.model_name  )






							@property
							def UpperCAmelCase_     (   self  ):
											return self.tokenizer.eos_token_id






							@cached_property
							def UpperCAmelCase_     (   self  ):
											warnings.simplefilter("""error"""  )
											_SCREAMING_SNAKE_CASE			:	TFMarianMTModel							=				TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name  )
											assert isinstance(__snake_case   , __snake_case  )
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				model.config
											self.assertListEqual(c.bad_words_ids   , [[c.pad_token_id]]  )
											self.assertEqual(c.max_length   , 512  )
											self.assertEqual(c.decoder_start_token_id   , c.pad_token_id  )
											return model






							def UpperCAmelCase_     (   self   , **__snake_case  ):
											_SCREAMING_SNAKE_CASE			:	Any							=				self.translate_src_text(**__snake_case  )
											self.assertListEqual(self.expected_text   , __snake_case  )






							def UpperCAmelCase_     (   self   , **__snake_case  ):
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				self.tokenizer(self.src_text   , **__snake_case   , padding=__snake_case   , return_tensors="""tf"""  )
											_SCREAMING_SNAKE_CASE			:	Any							=				self.model.generate(
											    model_inputs.input_ids   , attention_mask=model_inputs.attention_mask   , num_beams=2   , max_length=128  )
											_SCREAMING_SNAKE_CASE			:	int							=				self.tokenizer.batch_decode(generated_ids.numpy()   , skip_special_tokens=__snake_case  )
											return generated_words





@require_sentencepiece
@require_tokenizers
@require_tf
class    lowercase__  (						_snake_case ):





							'''simple docstring'''


							A_							:				Any				     =  """mt"""
							A_							:				Any				     =  """en"""
							A_							:				Tuple				     =  ["""Billi messu b'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem."""]
							A_							:				Tuple				     =  ["""Touching gently, Jesus healed a man who was affected by the sad disease of leprosy."""]






							@unittest.skip("""Skipping until #12647 is resolved."""  )
							@slow
							def UpperCAmelCase_     (   self  ):
											self._assert_generated_batch_equal_expected()





@require_sentencepiece
@require_tokenizers
@require_tf
class    lowercase__  (						_snake_case ):





							'''simple docstring'''


							A_							:				Optional[int]				     =  """en"""
							A_							:				str				     =  """zh"""
							A_							:				Union[str, Any]				     =  ["""My name is Wolfgang and I live in Berlin"""]
							A_							:				Optional[Any]				     =  ["""我叫沃尔夫冈 我住在柏林"""]






							@unittest.skip("""Skipping until #12647 is resolved."""  )
							@slow
							def UpperCAmelCase_     (   self  ):
											self._assert_generated_batch_equal_expected()





@require_sentencepiece
@require_tokenizers
@require_tf
class    lowercase__  (						_snake_case ):





							'''simple docstring'''


							A_							:				Any				     =  """en"""
							A_							:				Tuple				     =  """ROMANCE"""
							A_							:				Union[str, Any]				     =  [
							    """>>fr<< Don't spend so much time watching TV.""",
							    """>>pt<< Your message has been sent.""",
							    """>>es<< He's two years older than me.""",
							]
							A_							:				Optional[Any]				     =  [
							    """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 UpperCAmelCase_     (   self  ):
											self._assert_generated_batch_equal_expected()






							@unittest.skip("""Skipping until #12647 is resolved."""  )
							@slow
							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				TranslationPipeline(self.model   , self.tokenizer   , framework="""tf"""  )
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				pipeline(self.src_text  )
											self.assertEqual(self.expected_text   , [x["""translation_text"""] for x in output]  )








'''simple docstring'''


def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Tuple							=				1
				while b > 0:
								if b & 1:
												res *= a

								a *= a
								b >>= 1

				return res







def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				1
				while b > 0:
								if b & 1:
												_SCREAMING_SNAKE_CASE			:	Tuple							=				((res % c) * (a % c)) % c

								a *= a
								b >>= 1

				return res




