






"""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    lowercase_    :
      A__	:		Dict       			=				MBartConfig
      A__	:		Optional[Any]       			=				{}
      A__	:		Optional[Any]       			=				'''gelu'''






      def __init__(    self     ,     a_     ,     a_=1_3     ,     a_=7     ,     a_=True     ,     a_=False     ,     a_=9_9     ,     a_=3_2     ,     a_=2     ,     a_=4     ,     a_=3_7     ,     a_=0.1     ,     a_=0.1     ,     a_=2_0     ,     a_=2     ,     a_=1     ,     a_=0     ,     )	->List[str]:







        '''simple docstring'''


        _a							=	parent
        _a							=	batch_size
        _a							=	seq_length
        _a							=	is_training
        _a							=	use_labels
        _a							=	vocab_size
        _a							=	hidden_size
        _a							=	num_hidden_layers
        _a							=	num_attention_heads
        _a							=	intermediate_size
        _a							=	hidden_dropout_prob
        _a							=	attention_probs_dropout_prob
        _a							=	max_position_embeddings
        _a							=	eos_token_id
        _a							=	pad_token_id
        _a							=	bos_token_id






      def 			lowerCamelCase__    (    self	)	->Optional[Any]:







        '''simple docstring'''


        _a							=	ids_tensor([self.batch_size, self.seq_length - 1]     ,     self.vocab_size	)
        _a							=	tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size	)     ,     1	)
        _a							=	tf.concat([input_ids, eos_tensor]     ,     axis=1	)

        _a							=	ids_tensor([self.batch_size, self.seq_length]     ,     self.vocab_size	)

        _a							=	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     ,     )
        _a							=	prepare_mbart_inputs_dict(a_     ,     a_     ,     a_	)
        return config, inputs_dict






      def 			lowerCamelCase__    (    self     ,     a_     ,     a_	)	->List[str]:







        '''simple docstring'''


        _a							=	TFMBartModel(config=a_	).get_decoder()
        _a							=	inputs_dict["input_ids"]

        _a							=	input_ids[:1, :]
        _a							=	inputs_dict["attention_mask"][:1, :]
        _a							=	inputs_dict["head_mask"]
        _a							=	1

        # first forward pass
        _a							=	model(a_     ,     attention_mask=a_     ,     head_mask=a_     ,     use_cache=a_	)

        _a			,	_a							=	outputs.to_tuple()
        _a							=	past_key_values[1]







def        lowerCAmelCase (      UpperCamelCase_:							Dict     , UpperCamelCase_:							Optional[Any]     , UpperCamelCase_:							List[str]     , UpperCamelCase_:							Optional[Any]=None     , UpperCamelCase_:							Union[str, Any]=None     , UpperCamelCase_:							int=None     , UpperCamelCase_:							Optional[Any]=None     , UpperCamelCase_:							Any=None     , )       ->							Optional[int]:







  '''simple docstring'''







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






      def 			lowerCamelCase__    (    self     ,     a_     ,     a_     ,     a_     ,     a_     ,     a_	)	->List[Any]:







        '''simple docstring'''


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

        return False






      def 			lowerCamelCase__    (    self	)	->List[Any]:







        '''simple docstring'''


        _a							=	TFMBartModelTester(self	)
        _a							=	ConfigTester(self     ,     config_class=a_	)






      def 			lowerCamelCase__    (    self	)	->Any:







        '''simple docstring'''


        self.config_tester.run_common_tests()






      def 			lowerCamelCase__    (    self	)	->Union[str, Any]:







        '''simple docstring'''


        _a							=	self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_decoder_model_past_large_inputs(*a_	)







@require_sentencepiece
@require_tokenizers
@require_tf
class    lowercase_    (unittest.TestCase     ):
      A__	:		Dict       			=				[
          ''' UN Chief Says There Is No Military Solution in Syria''',
      ]
      A__	:		List[str]       			=				[
          '''Şeful ONU declară că nu există o soluţie militară în Siria''',
      ]
      A__	:		int       			=				'''facebook/mbart-large-en-ro'''






      @cached_property
      def 			lowerCamelCase__    (    self	)	->str:







        '''simple docstring'''


        return AutoTokenizer.from_pretrained(self.model_name	)






      @cached_property
      def 			lowerCamelCase__    (    self	)	->str:







        '''simple docstring'''


        _a							=	TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name	)
        return model






      def 			lowerCamelCase__    (    self     ,     **a_	)	->Optional[Any]:







        '''simple docstring'''


        _a							=	self.translate_src_text(**a_	)
        self.assertListEqual(self.expected_text     ,     a_	)






      def 			lowerCamelCase__    (    self     ,     **a_	)	->int:







        '''simple docstring'''


        _a							=	self.tokenizer(self.src_text     ,     **a_     ,     return_tensors="tf"	)
        _a							=	self.model.generate(
            model_inputs.input_ids     ,     attention_mask=model_inputs.attention_mask     ,     num_beams=2	)
        _a							=	self.tokenizer.batch_decode(a_     ,     skip_special_tokens=a_	)
        return generated_words






      @slow
      def 			lowerCamelCase__    (    self	)	->List[str]:







        '''simple docstring'''


        self._assert_generated_batch_equal_expected()










"""simple docstring"""




from ..utils import DummyObject, requires_backends




class    lowercase_    (metaclass=_UpperCAmelCase     ):
      A__	:		Any       			=				['''torch''', '''torchsde''']






      def __init__(    self     ,     *a_     ,     **a_	)	->Optional[int]:







        '''simple docstring'''


        requires_backends(self     ,     ["torch", "torchsde"]	)






      @classmethod
      def 			lowerCamelCase__    (    cls     ,     *a_     ,     **a_	)	->List[Any]:







        '''simple docstring'''


        requires_backends(cls     ,     ["torch", "torchsde"]	)






      @classmethod
      def 			lowerCamelCase__    (    cls     ,     *a_     ,     **a_	)	->str:







        '''simple docstring'''


        requires_backends(cls     ,     ["torch", "torchsde"]	)


