'''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 			lowerCamelCase_			:
      '''simple docstring'''

      __UpperCamelCase:						List[Any]      			=		MarianConfig
      __UpperCamelCase:						int      			=		{}
      __UpperCamelCase:						Any      			=		"gelu"




      def __init__( self		:       List[Any]		,      A		:       Tuple		,      A		:       str=13		,      A		:       List[Any]=7		,      A		:       List[Any]=True		,      A		:       int=False		,      A		:       Tuple=99		,      A		:       str=32		,      A		:       List[str]=2		,      A		:       List[str]=4		,      A		:       List[str]=37		,      A		:       int=0.1		,      A		:       Tuple=0.1		,      A		:       int=20		,      A		:       Any=2		,      A		:       int=1		,      A		:       List[Any]=0		,      ):
             _UpperCAmelCase  :						Optional[Any]							   =					parent
             _UpperCAmelCase  :						List[str]							   =					batch_size
             _UpperCAmelCase  :						List[Any]							   =					seq_length
             _UpperCAmelCase  :						int							   =					is_training
             _UpperCAmelCase  :						int							   =					use_labels
             _UpperCAmelCase  :						List[Any]							   =					vocab_size
             _UpperCAmelCase  :						Union[str, Any]							   =					hidden_size
             _UpperCAmelCase  :						List[Any]							   =					num_hidden_layers
             _UpperCAmelCase  :						str							   =					num_attention_heads
             _UpperCAmelCase  :						List[Any]							   =					intermediate_size

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




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

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

             _UpperCAmelCase  :						List[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		,      )
             _UpperCAmelCase  :						Optional[int]							   =					prepare_marian_inputs_dict(A		,      A		,      A )
             return config, inputs_dict





      def   _A			( self		:       Optional[Any]		,      A		:       Tuple		,      A		:       str ):
             _UpperCAmelCase  :						Optional[Any]							   =					TFMarianModel(config=A ).get_decoder()
             _UpperCAmelCase  :						List[str]							   =					inputs_dict["input_ids"]

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

             # first forward pass
             _UpperCAmelCase  :						Optional[int]							   =					model(A		,      attention_mask=A		,      head_mask=A		,      use_cache=A )

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

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

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

             _UpperCAmelCase  :						Dict							   =					model(A		,      attention_mask=A )[0]
             _UpperCAmelCase  :						int							   =					model(A		,      attention_mask=A		,      past_key_values=A )[0]

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

             # select random slice
             _UpperCAmelCase  :						List[Any]							   =					int(ids_tensor((1,)		,      output_from_past.shape[-1] ) )
             _UpperCAmelCase  :						Dict							   =					output_from_no_past[:, -3:, random_slice_idx]
             _UpperCAmelCase  :						str							   =					output_from_past[:, :, random_slice_idx]

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

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


       """simple docstring"""







       if attention_mask is None:
              _UpperCAmelCase  :						int							   =					tf.cast(tf.math.not_equal(_UpperCAmelCase    ,			config.pad_token_id					)    ,			tf.inta					)
       if decoder_attention_mask is None:
              _UpperCAmelCase  :						Dict							   =					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  :						Any							   =					tf.ones((config.encoder_layers, config.encoder_attention_heads)					)
       if decoder_head_mask is None:
              _UpperCAmelCase  :						Any							   =					tf.ones((config.decoder_layers, config.decoder_attention_heads)					)
       if cross_attn_head_mask is None:
              _UpperCAmelCase  :						int							   =					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 			lowerCamelCase_			(snake_case__							,				snake_case__							,				unittest.TestCase					):
      '''simple docstring'''

      __UpperCamelCase:						Any      			=		(TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
      __UpperCamelCase:						Optional[Any]      			=		(TFMarianMTModel,) if is_tf_available() else ()
      __UpperCamelCase:						int      			=		(
          {
              "conversational": TFMarianMTModel,
              "feature-extraction": TFMarianModel,
              "summarization": TFMarianMTModel,
              "text2text-generation": TFMarianMTModel,
              "translation": TFMarianMTModel,
          }
          if is_tf_available()
          else {}
      )
      __UpperCamelCase:						Union[str, Any]      			=		True
      __UpperCamelCase:						Dict      			=		False
      __UpperCamelCase:						List[str]      			=		False




      def   _A			( self		:       List[Any] ):
             _UpperCAmelCase  :						str							   =					TFMarianModelTester(self )
             _UpperCAmelCase  :						str							   =					ConfigTester(self		,      config_class=A )




      def   _A			( self		:       Optional[Any] ):
             self.config_tester.run_common_tests()





      def   _A			( self		:       Dict ):
             _UpperCAmelCase  :						List[Any]							   =					self.model_tester.prepare_config_and_inputs_for_common()
             self.model_tester.check_decoder_model_past_large_inputs(*A )

@require_tf
class 			lowerCamelCase_			(unittest.TestCase					):
      '''simple docstring'''

      __UpperCamelCase:						int      			=		1_0_0_0  # show more chars for failing integration tests




      @classmethod
      def   _A			( cls		:       Any ):
             _UpperCAmelCase  :						Any							   =					F"""Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"""
             return cls




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




      @property
      def   _A			( self		:       Tuple ):
             return self.tokenizer.eos_token_id




      @cached_property
      def   _A			( self		:       Union[str, Any] ):
             warnings.simplefilter("error" )
             _UpperCAmelCase  :						TFMarianMTModel							   =					TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name )
             assert isinstance(A		,      A )
             _UpperCAmelCase  :						Union[str, 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   _A			( self		:       Optional[Any]		,      **A		:       List[str] ):
             _UpperCAmelCase  :						Optional[int]							   =					self.translate_src_text(**A )
             self.assertListEqual(self.expected_text		,      A )





      def   _A			( self		:       Optional[Any]		,      **A		:       List[Any] ):
             _UpperCAmelCase  :						Union[str, Any]							   =					self.tokenizer(self.src_text		,      **A		,      padding=A		,      return_tensors="tf" )
             _UpperCAmelCase  :						Any							   =					self.model.generate(
                 model_inputs.input_ids		,      attention_mask=model_inputs.attention_mask		,      num_beams=2		,      max_length=128 )
             _UpperCAmelCase  :						Any							   =					self.tokenizer.batch_decode(generated_ids.numpy()		,      skip_special_tokens=A )
             return generated_words

@require_sentencepiece
@require_tokenizers
@require_tf
class 			lowerCamelCase_			(snake_case__					):
      '''simple docstring'''

      __UpperCamelCase:						int      			=		"mt"
      __UpperCamelCase:						List[str]      			=		"en"
      __UpperCamelCase:						Optional[Any]      			=		["Billi messu b'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem."]
      __UpperCamelCase:						Tuple      			=		["Touching gently, Jesus healed a man who was affected by the sad disease of leprosy."]




      @unittest.skip("Skipping until #12647 is resolved." )
      @slow
      def   _A			( self		:       str ):
             self._assert_generated_batch_equal_expected()

@require_sentencepiece
@require_tokenizers
@require_tf
class 			lowerCamelCase_			(snake_case__					):
      '''simple docstring'''

      __UpperCamelCase:						List[str]      			=		"en"
      __UpperCamelCase:						List[str]      			=		"zh"
      __UpperCamelCase:						Tuple      			=		["My name is Wolfgang and I live in Berlin"]
      __UpperCamelCase:						Optional[int]      			=		["我叫沃尔夫冈 我住在柏林"]




      @unittest.skip("Skipping until #12647 is resolved." )
      @slow
      def   _A			( self		:       Tuple ):
             self._assert_generated_batch_equal_expected()

@require_sentencepiece
@require_tokenizers
@require_tf
class 			lowerCamelCase_			(snake_case__					):
      '''simple docstring'''

      __UpperCamelCase:						str      			=		"en"
      __UpperCamelCase:						str      			=		"ROMANCE"
      __UpperCamelCase:						int      			=		[
          ">>fr<< Don't spend so much time watching TV.",
          ">>pt<< Your message has been sent.",
          ">>es<< He's two years older than me.",
      ]
      __UpperCamelCase:						Union[str, 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   _A			( self		:       str ):
             self._assert_generated_batch_equal_expected()





      @unittest.skip("Skipping until #12647 is resolved." )
      @slow
      def   _A			( self		:       int ):
             _UpperCAmelCase  :						int							   =					TranslationPipeline(self.model		,      self.tokenizer		,      framework="tf" )
             _UpperCAmelCase  :						Union[str, Any]							   =					pipeline(self.src_text )
             self.assertEqual(self.expected_text		,      [x["translation_text"] for x in output] )


'''simple docstring'''




from typing import TYPE_CHECKING

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


__SCREAMING_SNAKE_CASE :  Union[str, Any]  =						{
    """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
    """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __SCREAMING_SNAKE_CASE :  Optional[int]  =						[
      """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """GPTSanJapaneseForConditionalGeneration""",
      """GPTSanJapaneseModel""",
      """GPTSanJapanesePreTrainedModel""",
  ]
  __SCREAMING_SNAKE_CASE :  Union[str, Any]  =						[
      """GPTSanJapaneseTokenizer""",
  ]


if TYPE_CHECKING:
  from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
  from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_gptsan_japanese import (
        GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
        GPTSanJapaneseForConditionalGeneration,
        GPTSanJapaneseModel,
        GPTSanJapanesePreTrainedModel,
    )
    from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
  import sys

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

