





"""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   __SCREAMING_SNAKE_CASE     :







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:Optional[Any]						  =       MBartConfig
  SCREAMING_SNAKE_CASE__				:Tuple						  =       {}
  SCREAMING_SNAKE_CASE__				:Any						  =       'gelu'

  def __init__(		self :							int       , __a :							Optional[int]       , __a :							List[Any]=13       , __a :							Tuple=7       , __a :							Dict=True       , __a :							Dict=False       , __a :							Optional[Any]=99       , __a :							str=32       , __a :							str=2       , __a :							Union[str, Any]=4       , __a :							List[str]=37       , __a :							Any=0.1       , __a :							Tuple=0.1       , __a :							str=20       , __a :							Union[str, Any]=2       , __a :							List[str]=1       , __a :							Optional[Any]=0       , )		->					Any:
        _UpperCamelCase   :						str    =							parent
        _UpperCamelCase   :						Tuple    =							batch_size
        _UpperCamelCase   :						List[str]    =							seq_length
        _UpperCamelCase   :						List[Any]    =							is_training
        _UpperCamelCase   :						str    =							use_labels
        _UpperCamelCase   :						Any    =							vocab_size
        _UpperCamelCase   :						str    =							hidden_size
        _UpperCamelCase   :						str    =							num_hidden_layers
        _UpperCamelCase   :						Optional[int]    =							num_attention_heads
        _UpperCamelCase   :						List[str]    =							intermediate_size
        _UpperCamelCase   :						int    =							hidden_dropout_prob
        _UpperCamelCase   :						Dict    =							attention_probs_dropout_prob
        _UpperCamelCase   :						List[str]    =							max_position_embeddings
        _UpperCamelCase   :						Any    =							eos_token_id
        _UpperCamelCase   :						Dict    =							pad_token_id
        _UpperCamelCase   :						Dict    =							bos_token_id

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

        _UpperCamelCase   :						List[str]    =							ids_tensor([self.batch_size, self.seq_length]       , self.vocab_size						)

        _UpperCamelCase   :						List[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   :						Tuple    =							prepare_mbart_inputs_dict(SCREAMING_SNAKE_CASE_       , SCREAMING_SNAKE_CASE_       , SCREAMING_SNAKE_CASE_						)
        return config, inputs_dict


  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]       , __a :							Any       , __a :							List[str]						)		->					str:
        _UpperCamelCase   :						Optional[Any]    =							TFMBartModel(config=SCREAMING_SNAKE_CASE_						).get_decoder()
        _UpperCamelCase   :						Optional[Any]    =							inputs_dict["""input_ids"""]

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

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

        _UpperCamelCase   :						int    =							outputs.to_tuple()
        _UpperCamelCase   :						str    =							past_key_values[1]





def        lowercase__     (       lowercase_		,lowercase_		,lowercase_		,lowercase_=None		,lowercase_=None		,lowercase_=None		,lowercase_=None		,lowercase_=None		,)       ->		str:




      """simple docstring"""

      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   :						Optional[Any]    =							tf.ones((config.encoder_layers, config.encoder_attention_heads)      )
      if decoder_head_mask is None:
            _UpperCamelCase   :						Tuple    =							tf.ones((config.decoder_layers, config.decoder_attention_heads)      )
      if cross_attn_head_mask is None:
            _UpperCamelCase   :						Dict    =							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   __SCREAMING_SNAKE_CASE     (    UpperCAmelCase_		,	UpperCAmelCase_		,	unittest.TestCase ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:Any						  =       (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else ()
  SCREAMING_SNAKE_CASE__				:List[Any]						  =       (TFMBartForConditionalGeneration,) if is_tf_available() else ()
  SCREAMING_SNAKE_CASE__				:Optional[Any]						  =       (
      {
          'conversational': TFMBartForConditionalGeneration,
          'feature-extraction': TFMBartModel,
          'summarization': TFMBartForConditionalGeneration,
          'text2text-generation': TFMBartForConditionalGeneration,
          'translation': TFMBartForConditionalGeneration,
      }
      if is_tf_available()
      else {}
  )
  SCREAMING_SNAKE_CASE__				:Optional[int]						  =       True
  SCREAMING_SNAKE_CASE__				:str						  =       False
  SCREAMING_SNAKE_CASE__				:Union[str, Any]						  =       False

  def  __SCREAMING_SNAKE_CASE					(		self :							Any       , __a :							Union[str, Any]       , __a :							Optional[Any]       , __a :							Union[str, Any]       , __a :							Dict       , __a :							List[Any]						)		->					int:




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

        return False

  def  __SCREAMING_SNAKE_CASE					(		self :							Tuple						)		->					Any:
        _UpperCamelCase   :						Union[str, Any]    =							TFMBartModelTester(self						)
        _UpperCamelCase   :						Optional[int]    =							ConfigTester(self       , config_class=SCREAMING_SNAKE_CASE_						)

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


  def  __SCREAMING_SNAKE_CASE					(		self :							List[Any]						)		->					Tuple:
        _UpperCamelCase   :						List[str]    =							self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.check_decoder_model_past_large_inputs(*SCREAMING_SNAKE_CASE_						)





@require_sentencepiece
@require_tokenizers
@require_tf
class   __SCREAMING_SNAKE_CASE     (    unittest.TestCase ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__				:Optional[Any]						  =       [
      ' UN Chief Says There Is No Military Solution in Syria',
  ]
  SCREAMING_SNAKE_CASE__				:Any						  =       [
      'Şeful ONU declară că nu există o soluţie militară în Siria',
  ]
  SCREAMING_SNAKE_CASE__				:int						  =       'facebook/mbart-large-en-ro'

  @cached_property
  def  __SCREAMING_SNAKE_CASE					(		self :							List[Any]						)		->					List[str]:
        return AutoTokenizer.from_pretrained(self.model_name						)

  @cached_property
  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]						)		->					Tuple:
        _UpperCamelCase   :						Optional[Any]    =							TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name						)
        return model

  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]       , **__a :							Any						)		->					Union[str, Any]:
        _UpperCamelCase   :						Dict    =							self.translate_src_text(**SCREAMING_SNAKE_CASE_						)
        self.assertListEqual(self.expected_text       , SCREAMING_SNAKE_CASE_						)

  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]       , **__a :							Optional[int]						)		->					Union[str, Any]:
        _UpperCamelCase   :						List[Any]    =							self.tokenizer(self.src_text       , **SCREAMING_SNAKE_CASE_       , return_tensors="tf"						)
        _UpperCamelCase   :						Any    =							self.model.generate(
            model_inputs.input_ids       , attention_mask=model_inputs.attention_mask       , num_beams=2						)
        _UpperCamelCase   :						Union[str, Any]    =							self.tokenizer.batch_decode(SCREAMING_SNAKE_CASE_       , skip_special_tokens=SCREAMING_SNAKE_CASE_						)
        return generated_words


  @slow
  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[Any]						)		->					Any:
        self._assert_generated_batch_equal_expected()


lowerCamelCase__     :		List[str]        = """
# Installazione di Transformers
! pip install transformers datasets
# Per installare dalla fonte invece dell'ultima versione rilasciata, commenta il comando sopra e
# rimuovi la modalità commento al comando seguente.
# ! pip install git+https://github.com/huggingface/transformers.git
"""

lowerCamelCase__     :		List[Any]        = [{"""type""": """code""", """content""": INSTALL_CONTENT}]
lowerCamelCase__     :		int        = {
    """{processor_class}""": """FakeProcessorClass""",
    """{model_class}""": """FakeModelClass""",
    """{object_class}""": """FakeObjectClass""",
}






