


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__   		=     MarianConfig
       A__   		=     {}
       A__   		=     "gelu"





       def __init__(  self				:     Optional[Any]   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     List[str]=13   , __lowerCamelCase				:     Union[str, Any]=7   , __lowerCamelCase				:     int=True   , __lowerCamelCase				:     int=False   , __lowerCamelCase				:     List[Any]=99   , __lowerCamelCase				:     Dict=32   , __lowerCamelCase				:     Tuple=2   , __lowerCamelCase				:     Tuple=4   , __lowerCamelCase				:     str=37   , __lowerCamelCase				:     Dict=0.1   , __lowerCamelCase				:     Optional[int]=0.1   , __lowerCamelCase				:     List[str]=20   , __lowerCamelCase				:     Optional[Any]=2   , __lowerCamelCase				:     Union[str, Any]=1   , __lowerCamelCase				:     Dict=0   , ):


             '''simple docstring'''



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

             lowerCamelCase__						:							str       =    hidden_dropout_prob
             lowerCamelCase__						:							Optional[Any]       =    attention_probs_dropout_prob
             lowerCamelCase__						:							Union[str, Any]       =    max_position_embeddings
             lowerCamelCase__						:							Any       =    eos_token_id
             lowerCamelCase__						:							Tuple       =    pad_token_id
             lowerCamelCase__						:							Union[str, Any]       =    bos_token_id





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



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

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

             lowerCamelCase__						:							str       =    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   , )
             lowerCamelCase__						:							str       =    prepare_marian_inputs_dict(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase			)
             return config, inputs_dict





       def 		lowerCAmelCase	(  self				:     Dict   , __lowerCamelCase				:     Any   , __lowerCamelCase				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							str       =    TFMarianModel(config=__lowerCamelCase			).get_decoder()
             lowerCamelCase__						:							Dict       =    inputs_dict["input_ids"]

             lowerCamelCase__						:							Optional[Any]       =    input_ids[:1, :]
             lowerCamelCase__						:							List[str]       =    inputs_dict["attention_mask"][:1, :]
             lowerCamelCase__						:							Any       =    inputs_dict["head_mask"]
             lowerCamelCase__						:							Union[str, Any]       =    1

             # first forward pass
             lowerCamelCase__						:							int       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , head_mask=__lowerCamelCase   , use_cache=__lowerCamelCase			)

             lowerCamelCase__       ,  lowerCamelCase__						:							List[Any]       =    outputs.to_tuple()

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

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

             lowerCamelCase__						:							str       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase			)[0]
             lowerCamelCase__						:							Optional[int]       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , past_key_values=__lowerCamelCase			)[0]

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

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

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



def  lowercase_						(						_A     :       Dict       ,   _A     :       Optional[Any]       ,   _A     :       Optional[int]       ,   _A     :       List[Any]=None       ,   _A     :       int=None       ,   _A     :       Tuple=None       ,   _A     :       Optional[int]=None       ,   _A     :       List[str]=None       ,   ):

      """simple docstring"""




      if attention_mask is None:
            lowerCamelCase__						:							List[str]       =    tf.cast(tf.math.not_equal(_A       ,   config.pad_token_id		)       ,   tf.inta		)
      if decoder_attention_mask is None:
            lowerCamelCase__						:							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:
            lowerCamelCase__						:							Any       =    tf.ones((config.encoder_layers, config.encoder_attention_heads)		)
      if decoder_head_mask is None:
            lowerCamelCase__						:							List[Any]       =    tf.ones((config.decoder_layers, config.decoder_attention_heads)		)
      if cross_attn_head_mask is None:
            lowerCamelCase__						:							List[str]       =    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					(				lowercase__				,    lowercase__				,    unittest.TestCase):


       """simple docstring"""




       A__   		=     (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
       A__   		=     (TFMarianMTModel,) if is_tf_available() else ()
       A__   		=     (
           {
               "conversational": TFMarianMTModel,
               "feature-extraction": TFMarianModel,
               "summarization": TFMarianMTModel,
               "text2text-generation": TFMarianMTModel,
               "translation": TFMarianMTModel,
           }
           if is_tf_available()
           else {}
       )
       A__   		=     True
       A__   		=     False
       A__   		=     False





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    TFMarianModelTester(self			)
             lowerCamelCase__						:							List[Any]       =    ConfigTester(self   , config_class=__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             self.config_tester.run_common_tests()





       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    self.model_tester.prepare_config_and_inputs_for_common()
             self.model_tester.check_decoder_model_past_large_inputs(*__lowerCamelCase			)







@require_tf
class      _lowercase					(				unittest.TestCase):


       """simple docstring"""




       A__   		=     10_00  # show more chars for failing integration tests





       @classmethod
       def 		lowerCAmelCase	(  cls				:     Optional[Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Tuple       =    f"Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"
             return cls





       @cached_property
       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             return AutoTokenizer.from_pretrained(self.model_name			)





       @property
       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             return self.tokenizer.eos_token_id





       @cached_property
       def 		lowerCAmelCase	(  self				:     str			):


             '''simple docstring'''



             warnings.simplefilter("error"			)
             lowerCamelCase__						:							TFMarianMTModel       =    TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name			)
             assert isinstance(__lowerCamelCase   , __lowerCamelCase			)
             lowerCamelCase__						:							List[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 		lowerCAmelCase	(  self				:     Optional[int]   , **__lowerCamelCase				:     Optional[Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    self.translate_src_text(**__lowerCamelCase			)
             self.assertListEqual(self.expected_text   , __lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Union[str, Any]   , **__lowerCamelCase				:     List[Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							str       =    self.tokenizer(self.src_text   , **__lowerCamelCase   , padding=__lowerCamelCase   , return_tensors="tf"			)
             lowerCamelCase__						:							Dict       =    self.model.generate(
                 model_inputs.input_ids   , attention_mask=model_inputs.attention_mask   , num_beams=2   , max_length=128			)
             lowerCamelCase__						:							Dict       =    self.tokenizer.batch_decode(generated_ids.numpy()   , skip_special_tokens=__lowerCamelCase			)
             return generated_words







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


       """simple docstring"""




       A__   		=     "mt"
       A__   		=     "en"
       A__   		=     ["Billi messu b'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem."]
       A__   		=     ["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      _lowercase					(				lowercase__):


       """simple docstring"""




       A__   		=     "en"
       A__   		=     "zh"
       A__   		=     ["My name is Wolfgang and I live in Berlin"]
       A__   		=     ["我叫沃尔夫冈 我住在柏林"]





       @unittest.skip("Skipping until #12647 is resolved."			)
       @slow
       def 		lowerCAmelCase	(  self				:     Optional[int]			):


             '''simple docstring'''



             self._assert_generated_batch_equal_expected()







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


       """simple docstring"""




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


             '''simple docstring'''



             self._assert_generated_batch_equal_expected()





       @unittest.skip("Skipping until #12647 is resolved."			)
       @slow
       def 		lowerCAmelCase	(  self				:     Optional[int]			):


             '''simple docstring'''



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






from typing import TYPE_CHECKING

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


A :       Optional[int]						=   {
    "configuration_mpnet": ["MPNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "MPNetConfig"],
    "tokenization_mpnet": ["MPNetTokenizer"],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    A :       List[Any]						=   ["MPNetTokenizerFast"]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    A :       List[str]						=   [
        "MPNET_PRETRAINED_MODEL_ARCHIVE_LIST",
        "MPNetForMaskedLM",
        "MPNetForMultipleChoice",
        "MPNetForQuestionAnswering",
        "MPNetForSequenceClassification",
        "MPNetForTokenClassification",
        "MPNetLayer",
        "MPNetModel",
        "MPNetPreTrainedModel",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    A :       Tuple						=   [
        "TF_MPNET_PRETRAINED_MODEL_ARCHIVE_LIST",
        "TFMPNetEmbeddings",
        "TFMPNetForMaskedLM",
        "TFMPNetForMultipleChoice",
        "TFMPNetForQuestionAnswering",
        "TFMPNetForSequenceClassification",
        "TFMPNetForTokenClassification",
        "TFMPNetMainLayer",
        "TFMPNetModel",
        "TFMPNetPreTrainedModel",
    ]


if TYPE_CHECKING:
    from .configuration_mpnet import MPNET_PRETRAINED_CONFIG_ARCHIVE_MAP, MPNetConfig
    from .tokenization_mpnet import MPNetTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_mpnet_fast import MPNetTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_mpnet import (
            MPNET_PRETRAINED_MODEL_ARCHIVE_LIST,
            MPNetForMaskedLM,
            MPNetForMultipleChoice,
            MPNetForQuestionAnswering,
            MPNetForSequenceClassification,
            MPNetForTokenClassification,
            MPNetLayer,
            MPNetModel,
            MPNetPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_mpnet import (
            TF_MPNET_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFMPNetEmbeddings,
            TFMPNetForMaskedLM,
            TFMPNetForMultipleChoice,
            TFMPNetForQuestionAnswering,
            TFMPNetForSequenceClassification,
            TFMPNetForTokenClassification,
            TFMPNetMainLayer,
            TFMPNetModel,
            TFMPNetPreTrainedModel,
        )

else:
    import sys

    A :       Union[str, Any]						=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


