


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





     '''simple docstring'''



     __lowercase				:							Optional[int]	   =       MBartConfig
     __lowercase				:							Tuple	   =       {}
     __lowercase				:							Optional[int]	   =       'gelu'

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

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

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

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







     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]     ,		_a:Tuple     ,		_a:Any   ):
       snake_case__						= TFMBartModel(config=_a   ).get_decoder()
       snake_case__						= inputs_dict['''input_ids''']

       snake_case__						= input_ids[:1, :]
       snake_case__						= inputs_dict['''attention_mask'''][:1, :]
       snake_case__						= inputs_dict['''head_mask''']
       snake_case__						= 1

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

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







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   __lowerCAmelCase=None							,   )    ->				List[str]:
  if attention_mask is None:
    snake_case__						= tf.cast(tf.math.not_equal(__lowerCAmelCase							,   config.pad_token_id				)							,   tf.inta				)
  if decoder_attention_mask is None:
    snake_case__						= 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:
    snake_case__						= tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
  if decoder_head_mask is None:
    snake_case__						= tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
  if cross_attn_head_mask is None:
    snake_case__						= 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 		__magic_name__						(snake_case_   ,snake_case_   ,unittest.TestCase				):





     '''simple docstring'''



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

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict     ,		_a:str     ,		_a:Optional[int]     ,		_a:Optional[int]     ,		_a:List[Any]     ,		_a:int   ):
       if pipeline_test_casse_name != "FeatureExtractionPipelineTests":
         # Exception encountered when calling layer '...'
         return True

       return False

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       snake_case__						= TFMBartModelTester(self   )
       snake_case__						= ConfigTester(self     ,		config_class=_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       self.config_tester.run_common_tests()







     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       snake_case__						= 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 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



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

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

     @cached_property
     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       snake_case__						= TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name   )
       return model

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]     ,		**_a:Optional[Any]   ):
       snake_case__						= self.translate_src_text(**_a   )
       self.assertListEqual(self.expected_text     ,		_a   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict     ,		**_a:Optional[int]   ):
       snake_case__						= self.tokenizer(self.src_text     ,		**_a     ,		return_tensors='''tf'''   )
       snake_case__						= self.model.generate(
           model_inputs.input_ids     ,		attention_mask=model_inputs.attention_mask     ,		num_beams=2   )
       snake_case__						= self.tokenizer.batch_decode(_a     ,		skip_special_tokens=_a   )
       return generated_words







     @slow
     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       self._assert_generated_batch_equal_expected()





import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin
@skip_mps
class 		__magic_name__						(snake_case_   ,snake_case_   ,unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							str	   =       IFImgaImgSuperResolutionPipeline
     __lowercase				:							Optional[Any]	   =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
     __lowercase				:							int	   =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}				)
     __lowercase				:							List[str]	   =       PipelineTesterMixin.required_optional_params - {'latents'}

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       return self._get_superresolution_dummy_components()

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict     ,		_a:int     ,		_a:Optional[Any]=0   ):
       if str(_a   ).startswith('''mps'''   ):
         snake_case__						= torch.manual_seed(_a   )
       else:
         snake_case__						= torch.Generator(device=_a   ).manual_seed(_a   )

       snake_case__						= floats_tensor((1, 3, 32, 32)     ,		rng=random.Random(_a   )   ).to(_a   )
       snake_case__						= floats_tensor((1, 3, 16, 16)     ,		rng=random.Random(_a   )   ).to(_a   )

       snake_case__						= {
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''image''': image,
           '''original_image''': original_image,
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''output_type''': '''numpy''',
       }

       return inputs

     @unittest.skipIf(
         torch_device != '''cuda''' or not is_xformers_available()     ,		reason='''XFormers attention is only available with CUDA and `xformers` installed'''     ,		)
     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       self._test_save_load_optional_components()

     @unittest.skipIf(torch_device != '''cuda'''     ,		reason='''float16 requires CUDA'''   )
     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
       super().test_save_load_floataa(expected_max_diff=1e-1   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       self._test_attention_slicing_forward_pass(expected_max_diff=1e-2   )

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       self._test_save_load_local()







     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       self._test_inference_batch_single_identical(
           expected_max_diff=1e-2     ,		)

