





"""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 	__a   :
     SCREAMING_SNAKE_CASE__ :      Tuple       		=			MarianConfig
     SCREAMING_SNAKE_CASE__ :      str       		=			{}
     SCREAMING_SNAKE_CASE__ :      List[str]       		=			"gelu"



     def __init__(       self					,     a__					,     a__=13					,     a__=7					,     a__=True					,     a__=False					,     a__=99					,     a__=32					,     a__=2					,     a__=4					,     a__=37					,     a__=0.1					,     a__=0.1					,     a__=20					,     a__=2					,     a__=1					,     a__=0					,     ):
            _lowerCamelCase    	=					parent
            _lowerCamelCase    	=					batch_size
            _lowerCamelCase    	=					seq_length
            _lowerCamelCase    	=					is_training
            _lowerCamelCase    	=					use_labels
            _lowerCamelCase    	=					vocab_size
            _lowerCamelCase    	=					hidden_size
            _lowerCamelCase    	=					num_hidden_layers
            _lowerCamelCase    	=					num_attention_heads
            _lowerCamelCase    	=					intermediate_size

            _lowerCamelCase    	=					hidden_dropout_prob
            _lowerCamelCase    	=					attention_probs_dropout_prob
            _lowerCamelCase    	=					max_position_embeddings
            _lowerCamelCase    	=					eos_token_id
            _lowerCamelCase    	=					pad_token_id
            _lowerCamelCase    	=					bos_token_id



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

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

            _lowerCamelCase    	=					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    	=					prepare_marian_inputs_dict(UpperCAmelCase_					,     UpperCAmelCase_					,     UpperCAmelCase_   )
            return config, inputs_dict



     def 						snake_case_			(       self					,     a__					,     a__   ):
            _lowerCamelCase    	=					TFMarianModel(config=UpperCAmelCase_   ).get_decoder()
            _lowerCamelCase    	=					inputs_dict['input_ids']

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

            # first forward pass
            _lowerCamelCase    	=					model(UpperCAmelCase_					,     attention_mask=UpperCAmelCase_					,     head_mask=UpperCAmelCase_					,     use_cache=UpperCAmelCase_   )

            _lowerCamelCase	,	_lowerCamelCase    	=					outputs.to_tuple()

            # create hypothetical next token and extent to next_input_ids
            _lowerCamelCase    	=					ids_tensor((self.batch_size, 3)					,     config.vocab_size   )
            _lowerCamelCase    	=					tf.cast(ids_tensor((self.batch_size, 3)					,     2   )					,     tf.inta   )

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

            _lowerCamelCase    	=					model(UpperCAmelCase_					,     attention_mask=UpperCAmelCase_   )[0]
            _lowerCamelCase    	=					model(UpperCAmelCase_					,     attention_mask=UpperCAmelCase_					,     past_key_values=UpperCAmelCase_   )[0]

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

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

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





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



     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					TFMarianModelTester(self   )
            _lowerCamelCase    	=					ConfigTester(self					,     config_class=UpperCAmelCase_   )



     def 						snake_case_			(       self   ):
            self.config_tester.run_common_tests()



     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					self.model_tester.prepare_config_and_inputs_for_common()
            self.model_tester.check_decoder_model_past_large_inputs(*UpperCAmelCase_   )







@require_tf
class 	__a   (  unittest.TestCase		):
     SCREAMING_SNAKE_CASE__ :      List[str]       		=			1000  # show more chars for failing integration tests



     @classmethod
     def 						snake_case_			(       cls   ):
            _lowerCamelCase    	=					F'Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}'
            return cls



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



     @property
     def 						snake_case_			(       self   ):
            return self.tokenizer.eos_token_id



     @cached_property
     def 						snake_case_			(       self   ):
            warnings.simplefilter('error'   )
            _lowerCamelCase    	=					TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name   )
            assert isinstance(UpperCAmelCase_					,     UpperCAmelCase_   )
            _lowerCamelCase    	=					model.config
            self.assertListEqual(c.bad_words_ids					,     [[c.pad_token_id]]   )
            self.assertEqual(c.max_length					,     5_12   )
            self.assertEqual(c.decoder_start_token_id					,     c.pad_token_id   )
            return model



     def 						snake_case_			(       self					,     **a__   ):
            _lowerCamelCase    	=					self.translate_src_text(**UpperCAmelCase_   )
            self.assertListEqual(self.expected_text					,     UpperCAmelCase_   )



     def 						snake_case_			(       self					,     **a__   ):
            _lowerCamelCase    	=					self.tokenizer(self.src_text					,     **UpperCAmelCase_					,     padding=UpperCAmelCase_					,     return_tensors='tf'   )
            _lowerCamelCase    	=					self.model.generate(
                model_inputs.input_ids					,     attention_mask=model_inputs.attention_mask					,     num_beams=2					,     max_length=1_28   )
            _lowerCamelCase    	=					self.tokenizer.batch_decode(generated_ids.numpy()					,     skip_special_tokens=UpperCAmelCase_   )
            return generated_words







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



     @unittest.skip('Skipping until #12647 is resolved.'   )
     @slow
     def 						snake_case_			(       self   ):
            self._assert_generated_batch_equal_expected()







@require_sentencepiece
@require_tokenizers
@require_tf
class 	__a   (  lowerCAmelCase__		):
     SCREAMING_SNAKE_CASE__ :      Any       		=			"en"
     SCREAMING_SNAKE_CASE__ :      Tuple       		=			"zh"
     SCREAMING_SNAKE_CASE__ :      List[str]       		=			["My name is Wolfgang and I live in Berlin"]
     SCREAMING_SNAKE_CASE__ :      List[str]       		=			["我叫沃尔夫冈 我住在柏林"]



     @unittest.skip('Skipping until #12647 is resolved.'   )
     @slow
     def 						snake_case_			(       self   ):
            self._assert_generated_batch_equal_expected()







@require_sentencepiece
@require_tokenizers
@require_tf
class 	__a   (  lowerCAmelCase__		):
     SCREAMING_SNAKE_CASE__ :      Dict       		=			"en"
     SCREAMING_SNAKE_CASE__ :      Optional[Any]       		=			"ROMANCE"
     SCREAMING_SNAKE_CASE__ :      Tuple       		=			[
         ">>fr<< Don't spend so much time watching TV.",
         ">>pt<< Your message has been sent.",
         ">>es<< He's two years older than me.",
     ]
     SCREAMING_SNAKE_CASE__ :      Any       		=			[
         "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 						snake_case_			(       self   ):
            self._assert_generated_batch_equal_expected()



     @unittest.skip('Skipping until #12647 is resolved.'   )
     @slow
     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					TranslationPipeline(self.model					,     self.tokenizer					,     framework='tf'   )
            _lowerCamelCase    	=					pipeline(self.src_text   )
            self.assertEqual(self.expected_text					,     [x['translation_text'] for x in output]   )













from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, is_invisible_watermark_available, is_torch_available, is_transformers_available

@dataclass
class 					__A   (  a			):
				__A            = 42


if is_transformers_available() and is_torch_available() and is_invisible_watermark_available():
							from .pipeline_stable_diffusion_xl import StableDiffusionXLPipeline
							from .pipeline_stable_diffusion_xl_imgaimg import StableDiffusionXLImgaImgPipeline





