






'''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,
)


UpperCamelCase__	=     {'configuration_t5': ['T5_PRETRAINED_CONFIG_ARCHIVE_MAP', 'T5Config', 'T5OnnxConfig']}

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

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

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCamelCase__	=     [
     '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:
 UpperCamelCase__	=     [
     'TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFT5EncoderModel',
     'TFT5ForConditionalGeneration',
     'TFT5Model',
     'TFT5PreTrainedModel',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCamelCase__	=     [
     '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

 UpperCamelCase__	=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)












'''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     _UpperCAmelCase  :
    __lowerCamelCase:				Any						    =      MarianConfig
    __lowerCamelCase:				Optional[int]						    =      {}
    __lowerCamelCase:				Optional[Any]						    =      'gelu'




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






       '''simple docstring'''






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

       lowercase_		:      List[Any]          =       hidden_dropout_prob
       lowercase_		:      List[str]          =       attention_probs_dropout_prob
       lowercase_		:      str          =       max_position_embeddings
       lowercase_		:      Optional[int]          =       eos_token_id
       lowercase_		:      Dict          =       pad_token_id
       lowercase_		:      Any          =       bos_token_id




    def 			lowerCAmelCase__			(     self					:    List[Any]     ):






       '''simple docstring'''






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

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

       lowercase_		:      int          =       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					,       )
       lowercase_		:      Dict          =       prepare_marian_inputs_dict(a					,       a					,       a     )
       return config, inputs_dict





    def 			lowerCAmelCase__			(     self					:    Any					,       a					:    Optional[int]					,       a					:    Tuple     ):






       '''simple docstring'''






       lowercase_		:      str          =       TFMarianModel(config=a     ).get_decoder()
       lowercase_		:      List[Any]          =       inputs_dict["input_ids"]

       lowercase_		:      Any          =       input_ids[:1, :]
       lowercase_		:      int          =       inputs_dict["attention_mask"][:1, :]
       lowercase_		:      List[Any]          =       inputs_dict["head_mask"]
       lowercase_		:      List[str]          =       1

       # first forward pass
       lowercase_		:      List[str]          =       model(a					,       attention_mask=a					,       head_mask=a					,       use_cache=a     )

       lowercase_      ,						lowercase_		:      Tuple          =       outputs.to_tuple()

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

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

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

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




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase  ,						_UpperCamelCase  ,						_UpperCamelCase  ,						_UpperCamelCase=None  ,						_UpperCamelCase=None  ,						_UpperCamelCase=None  ,						_UpperCamelCase=None  ,						_UpperCamelCase=None  ,						):


   """simple docstring"""




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




    def 			lowerCAmelCase__			(     self					:    List[str]     ):






       '''simple docstring'''






       lowercase_		:      Any          =       TFMarianModelTester(self     )
       lowercase_		:      Union[str, Any]          =       ConfigTester(self					,       config_class=a     )




    def 			lowerCAmelCase__			(     self					:    str     ):






       '''simple docstring'''






       self.config_tester.run_common_tests()





    def 			lowerCAmelCase__			(     self					:    Dict     ):






       '''simple docstring'''






       lowercase_		:      Tuple          =       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     ):
    __lowerCamelCase:				Any						    =      1000  # show more chars for failing integration tests




    @classmethod
    def 			lowerCAmelCase__			(     cls					:    Optional[int]     ):






       '''simple docstring'''






       lowercase_		:      Union[str, Any]          =       f"""Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"""
       return cls




    @cached_property
    def 			lowerCAmelCase__			(     self					:    List[Any]     ):






       '''simple docstring'''






       return AutoTokenizer.from_pretrained(self.model_name     )




    @property
    def 			lowerCAmelCase__			(     self					:    List[str]     ):






       '''simple docstring'''






       return self.tokenizer.eos_token_id




    @cached_property
    def 			lowerCAmelCase__			(     self					:    Dict     ):






       '''simple docstring'''






       warnings.simplefilter("error"     )
       lowercase_		:      TFMarianMTModel          =       TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name     )
       assert isinstance(a					,       a     )
       lowercase_		:      Union[str, Any]          =       model.config
       self.assertListEqual(c.bad_words_ids					,       [[c.pad_token_id]]     )
       self.assertEqual(c.max_length					,       5_1_2     )
       self.assertEqual(c.decoder_start_token_id					,       c.pad_token_id     )
       return model




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






       '''simple docstring'''






       lowercase_		:      int          =       self.translate_src_text(**a     )
       self.assertListEqual(self.expected_text					,       a     )





    def 			lowerCAmelCase__			(     self					:    List[str]					,       **a					:    str     ):






       '''simple docstring'''






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


@require_sentencepiece
@require_tokenizers
@require_tf
class     _UpperCAmelCase  (						snake_case     ):
    __lowerCamelCase:				int						    =      'mt'
    __lowerCamelCase:				Union[str, Any]						    =      'en'
    __lowerCamelCase:				Optional[Any]						    =      ['Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.']
    __lowerCamelCase:				Optional[Any]						    =      ['Touching gently, Jesus healed a man who was affected by the sad disease of leprosy.']




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






       '''simple docstring'''






       self._assert_generated_batch_equal_expected()


@require_sentencepiece
@require_tokenizers
@require_tf
class     _UpperCAmelCase  (						snake_case     ):
    __lowerCamelCase:				Union[str, Any]						    =      'en'
    __lowerCamelCase:				str						    =      'zh'
    __lowerCamelCase:				str						    =      ['My name is Wolfgang and I live in Berlin']
    __lowerCamelCase:				int						    =      ['我叫沃尔夫冈 我住在柏林']




    @unittest.skip("Skipping until #12647 is resolved."     )
    @slow
    def 			lowerCAmelCase__			(     self					:    List[Any]     ):






       '''simple docstring'''






       self._assert_generated_batch_equal_expected()


@require_sentencepiece
@require_tokenizers
@require_tf
class     _UpperCAmelCase  (						snake_case     ):
    __lowerCamelCase:				List[Any]						    =      'en'
    __lowerCamelCase:				List[str]						    =      'ROMANCE'
    __lowerCamelCase:				int						    =      [
        '>>fr<< Don\'t spend so much time watching TV.',
        '>>pt<< Your message has been sent.',
        '>>es<< He\'s two years older than me.',
    ]
    __lowerCamelCase:				Tuple						    =      [
        '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 			lowerCAmelCase__			(     self					:    Tuple     ):






       '''simple docstring'''






       self._assert_generated_batch_equal_expected()





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






       '''simple docstring'''






       lowercase_		:      Optional[int]          =       TranslationPipeline(self.model					,       self.tokenizer					,       framework="tf"     )
       lowercase_		:      Tuple          =       pipeline(self.src_text     )
       self.assertEqual(self.expected_text					,       [x["translation_text"] for x in output]     )




