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





	_UpperCamelCase							:  Optional[int]								=		MarianConfig
	_UpperCamelCase							:  Union[str, Any]								=		{}
	_UpperCamelCase							:  Tuple								=		'''gelu'''




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

			lowerCAmelCase_   :       List[str]    							=hidden_dropout_prob
			lowerCAmelCase_   :       Union[str, Any]    							=attention_probs_dropout_prob
			lowerCAmelCase_   :       Optional[Any]    							=max_position_embeddings
			lowerCAmelCase_   :       Tuple    							=eos_token_id
			lowerCAmelCase_   :       Any    							=pad_token_id
			lowerCAmelCase_   :       Union[str, Any]    							=bos_token_id




	def 	__A      (						self				: List[str]      ):
			lowerCAmelCase_   :       Union[str, Any]    							=ids_tensor([self.batch_size, self.seq_length - 1]					,						self.vocab_size      )
			lowerCAmelCase_   :       List[str]    							=tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size      )					,						1      )
			lowerCAmelCase_   :       str    							=tf.concat([input_ids, eos_tensor]					,						axis=1      )

			lowerCAmelCase_   :       Dict    							=ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size      )

			lowerCAmelCase_   :       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					,						)
			lowerCAmelCase_   :       List[str]    							=prepare_marian_inputs_dict(UpperCamelCase__					,						UpperCamelCase__					,						UpperCamelCase__      )
			return config, inputs_dict





	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: List[Any]					,						UpperCamelCase_				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[Any]    							=TFMarianModel(config=UpperCamelCase__      ).get_decoder()
			lowerCAmelCase_   :       List[str]    							=inputs_dict["""input_ids"""]

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

			# first forward pass
			lowerCAmelCase_   :       Dict    							=model(UpperCamelCase__					,						attention_mask=UpperCamelCase__					,						head_mask=UpperCamelCase__					,						use_cache=UpperCamelCase__      )

			lowerCAmelCase_   :       Optional[Any]    							=outputs.to_tuple()

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

			# append to next input_ids and
			lowerCAmelCase_   :       Tuple    							=tf.concat([input_ids, next_tokens]					,						axis=-1      )
			lowerCAmelCase_   :       List[str]    							=tf.concat([attention_mask, next_attn_mask]					,						axis=-1      )

			lowerCAmelCase_   :       int    							=model(UpperCamelCase__					,						attention_mask=UpperCamelCase__      )[0]
			lowerCAmelCase_   :       Union[str, Any]    							=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_   :       Dict    							=int(ids_tensor((1,)					,						output_from_past.shape[-1]      )      )
			lowerCAmelCase_   :       Any    							=output_from_no_past[:, -3:, random_slice_idx]
			lowerCAmelCase_   :       Any    							=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__					(							_SCREAMING_SNAKE_CASE  ,					_SCREAMING_SNAKE_CASE  ,					_SCREAMING_SNAKE_CASE  ,					_SCREAMING_SNAKE_CASE=None  ,					_SCREAMING_SNAKE_CASE=None  ,					_SCREAMING_SNAKE_CASE=None  ,					_SCREAMING_SNAKE_CASE=None  ,					_SCREAMING_SNAKE_CASE=None  ,					):
		if attention_mask is None:
				lowerCAmelCase_   :       Optional[int]    							=tf.cast(tf.math.not_equal(_SCREAMING_SNAKE_CASE  ,					config.pad_token_id  )  ,					tf.inta  )
		if decoder_attention_mask is None:
				lowerCAmelCase_   :       Optional[int]    							=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_   :       List[Any]    							=tf.ones((config.encoder_layers, config.encoder_attention_heads)  )
		if decoder_head_mask is None:
				lowerCAmelCase_   :       Tuple    							=tf.ones((config.decoder_layers, config.decoder_attention_heads)  )
		if cross_attn_head_mask is None:
				lowerCAmelCase_   :       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 							_snake_case     (  _lowercase						,    _lowercase						,    unittest.TestCase ):
	"""simple docstring"""





	_UpperCamelCase							:  List[Any]								=		(TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
	_UpperCamelCase							:  int								=		(TFMarianMTModel,) if is_tf_available() else ()
	_UpperCamelCase							:  List[Any]								=		(
	    {
	        '''conversational''': TFMarianMTModel,
	        '''feature-extraction''': TFMarianModel,
	        '''summarization''': TFMarianMTModel,
	        '''text2text-generation''': TFMarianMTModel,
	        '''translation''': TFMarianMTModel,
	    }
	    if is_tf_available()
	    else {}
	)
	_UpperCamelCase							:  Dict								=		True
	_UpperCamelCase							:  Tuple								=		False
	_UpperCamelCase							:  Dict								=		False




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       Optional[Any]    							=TFMarianModelTester(self      )
			lowerCAmelCase_   :       Optional[Any]    							=ConfigTester(self					,						config_class=UpperCamelCase__      )




	def 	__A      (						self				: List[str]      ):
			self.config_tester.run_common_tests()





	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Union[str, Any]    							=self.model_tester.prepare_config_and_inputs_for_common()
			self.model_tester.check_decoder_model_past_large_inputs(*UpperCamelCase__      )







@require_tf
class 							_snake_case     (  unittest.TestCase ):
	"""simple docstring"""





	_UpperCamelCase							:  Dict								=		1_000  # show more chars for failing integration tests




	@classmethod
	def 	__A      (						cls				: Tuple      ):
			lowerCAmelCase_   :       Optional[Any]    							=F'Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}'
			return cls




	@cached_property
	def 	__A      (						self				: Optional[Any]      ):
			return AutoTokenizer.from_pretrained(self.model_name      )




	@property
	def 	__A      (						self				: Dict      ):
			return self.tokenizer.eos_token_id




	@cached_property
	def 	__A      (						self				: List[Any]      ):
			warnings.simplefilter('''error'''      )
			lowerCAmelCase_   :       TFMarianMTModel    							=TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name      )
			assert isinstance(UpperCamelCase__					,						UpperCamelCase__      )
			lowerCAmelCase_   :       Optional[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				: List[Any]					,						**UpperCamelCase_				: Union[str, Any]      ):
			lowerCAmelCase_   :       List[str]    							=self.translate_src_text(**UpperCamelCase__      )
			self.assertListEqual(self.expected_text					,						UpperCamelCase__      )





	def 	__A      (						self				: Dict					,						**UpperCamelCase_				: List[Any]      ):
			lowerCAmelCase_   :       List[Any]    							=self.tokenizer(self.src_text					,						**UpperCamelCase__					,						padding=UpperCamelCase__					,						return_tensors='''tf'''      )
			lowerCAmelCase_   :       Tuple    							=self.model.generate(
			    model_inputs.input_ids					,						attention_mask=model_inputs.attention_mask					,						num_beams=2					,						max_length=128      )
			lowerCAmelCase_   :       Union[str, Any]    							=self.tokenizer.batch_decode(generated_ids.numpy()					,						skip_special_tokens=UpperCamelCase__      )
			return generated_words







@require_sentencepiece
@require_tokenizers
@require_tf
class 							_snake_case     (  _lowercase ):
	"""simple docstring"""





	_UpperCamelCase							:  Union[str, Any]								=		'''mt'''
	_UpperCamelCase							:  Dict								=		'''en'''
	_UpperCamelCase							:  Optional[int]								=		['''Billi messu b\'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem.''']
	_UpperCamelCase							:  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 	__A      (						self				: List[Any]      ):
			self._assert_generated_batch_equal_expected()







@require_sentencepiece
@require_tokenizers
@require_tf
class 							_snake_case     (  _lowercase ):
	"""simple docstring"""





	_UpperCamelCase							:  List[str]								=		'''en'''
	_UpperCamelCase							:  List[str]								=		'''zh'''
	_UpperCamelCase							:  Union[str, Any]								=		['''My name is Wolfgang and I live in Berlin''']
	_UpperCamelCase							:  List[str]								=		['''我叫沃尔夫冈 我住在柏林''']




	@unittest.skip('''Skipping until #12647 is resolved.'''      )
	@slow
	def 	__A      (						self				: Optional[Any]      ):
			self._assert_generated_batch_equal_expected()







@require_sentencepiece
@require_tokenizers
@require_tf
class 							_snake_case     (  _lowercase ):
	"""simple docstring"""





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





	@unittest.skip('''Skipping until #12647 is resolved.'''      )
	@slow
	def 	__A      (						self				: str      ):
			lowerCAmelCase_   :       Optional[Any]    							=TranslationPipeline(self.model					,						self.tokenizer					,						framework='''tf'''      )
			lowerCAmelCase_   :       Optional[int]    							=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_torch_available, is_vision_available


_A      :     Tuple       	={
    '''configuration_imagegpt''': ['''IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ImageGPTConfig''', '''ImageGPTOnnxConfig''']
}

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A      :     Dict       	=['''ImageGPTFeatureExtractor''']
			_A      :     Union[str, Any]       	=['''ImageGPTImageProcessor''']

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A      :     str       	=[
			    '''IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''ImageGPTForCausalImageModeling''',
			    '''ImageGPTForImageClassification''',
			    '''ImageGPTModel''',
			    '''ImageGPTPreTrainedModel''',
			    '''load_tf_weights_in_imagegpt''',
			]


if TYPE_CHECKING:
			from .configuration_imagegpt import IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ImageGPTConfig, ImageGPTOnnxConfig

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .feature_extraction_imagegpt import ImageGPTFeatureExtractor
						from .image_processing_imagegpt import ImageGPTImageProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_imagegpt import (
						    IMAGEGPT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    ImageGPTForCausalImageModeling,
						    ImageGPTForImageClassification,
						    ImageGPTModel,
						    ImageGPTPreTrainedModel,
						    load_tf_weights_in_imagegpt,
						)

else:
			import sys

			_A      :     str       	=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

