





import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
				import os

				# The slow tests are often failing with OOM error on GPU
				# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
				# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
				snake_case_				=      '''platform'''

				import jax
				import jax.numpy as jnp

				from transformers import AutoTokenizer
				from transformers.models.mbart.modeling_flax_mbart import (
				    FlaxMBartForConditionalGeneration,
				    FlaxMBartForQuestionAnswering,
				    FlaxMBartForSequenceClassification,
				    FlaxMBartModel,
				    shift_tokens_right,
				)


def        A__						(							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				,							SCREAMING_SNAKE_CASE_=None				,							) ->  Tuple:
		if attention_mask is None:
				lowerCamelCase :			Tuple    		=np.where(input_ids != config.pad_token_id				,							1				,							0		)
		if decoder_attention_mask is None:
				lowerCamelCase :			List[Any]    		=np.where(decoder_input_ids != config.pad_token_id				,							1				,							0		)
		if head_mask is None:
				lowerCamelCase :			int    		=np.ones((config.encoder_layers, config.encoder_attention_heads)		)
		if decoder_head_mask is None:
				lowerCamelCase :			Optional[Any]    		=np.ones((config.decoder_layers, config.decoder_attention_heads)		)
		if cross_attn_head_mask is None:
				lowerCamelCase :			Optional[Any]    		=np.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,
		}
class 							snake_case_		(      unittest.TestCase):







		def __init__(		self      ,  __lowercase      ,  __lowercase=1_3      ,  __lowercase=7      ,  __lowercase=True      ,  __lowercase=False      ,  __lowercase=9_9      ,  __lowercase=1_6      ,  __lowercase=2      ,  __lowercase=4      ,  __lowercase=4      ,  __lowercase="gelu"      ,  __lowercase=0.1      ,  __lowercase=0.1      ,  __lowercase=3_2      ,  __lowercase=2      ,  __lowercase=1      ,  __lowercase=0      ,  __lowercase=2      ,  __lowercase=0.0_2      ,  )					-> Dict:
				lowerCamelCase :			Any    		=parent
				lowerCamelCase :			List[str]    		=batch_size
				lowerCamelCase :			int    		=seq_length
				lowerCamelCase :			Dict    		=is_training
				lowerCamelCase :			List[Any]    		=use_labels
				lowerCamelCase :			Union[str, Any]    		=vocab_size
				lowerCamelCase :			Optional[Any]    		=hidden_size
				lowerCamelCase :			Any    		=num_hidden_layers
				lowerCamelCase :			Optional[int]    		=num_attention_heads
				lowerCamelCase :			Optional[int]    		=intermediate_size
				lowerCamelCase :			Optional[int]    		=hidden_act
				lowerCamelCase :			Dict    		=hidden_dropout_prob
				lowerCamelCase :			Optional[int]    		=attention_probs_dropout_prob
				lowerCamelCase :			List[Any]    		=max_position_embeddings
				lowerCamelCase :			List[str]    		=eos_token_id
				lowerCamelCase :			Union[str, Any]    		=pad_token_id
				lowerCamelCase :			str    		=bos_token_id
				lowerCamelCase :			str    		=decoder_start_token_id
				lowerCamelCase :			int    		=initializer_range







		def       __lowercase (		self )					-> List[Any]:
				lowerCamelCase :			Any    		=np.clip(ids_tensor([self.batch_size, self.seq_length - 1]      ,  self.vocab_size )      ,  3      ,  self.vocab_size )
				lowerCamelCase :			Tuple    		=np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)      ,  dtype=np.intaa ))      ,  -1 )

				lowerCamelCase :			List[Any]    		=shift_tokens_right(__lowercase      ,  1 )

				lowerCamelCase :			int    		=MBartConfig(
				    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_id=self.eos_token_id      ,  bos_token_id=self.bos_token_id      ,  pad_token_id=self.pad_token_id      ,  decoder_start_token_id=self.decoder_start_token_id      ,  initializer_range=self.initializer_range      ,  use_cache=__lowercase      ,  )
				lowerCamelCase :			Tuple    		=prepare_mbart_inputs_dict(__lowercase      ,  __lowercase      ,  __lowercase )
				return config, inputs_dict







		def       __lowercase (		self )					-> List[str]:
				lowerCamelCase		, lowerCamelCase :			Optional[int]    		=self.prepare_config_and_inputs()
				return config, inputs_dict







		def       __lowercase (		self      ,  __lowercase      ,  __lowercase      ,  __lowercase )					-> List[Any]:
				lowerCamelCase :			List[str]    		=2_0
				lowerCamelCase :			Dict    		=model_class_name(__lowercase )

				lowerCamelCase :			Tuple    		=model.encode(inputs_dict['''input_ids'''] )

				lowerCamelCase		, lowerCamelCase :			Union[str, Any]    		=(
				    inputs_dict['''decoder_input_ids'''],
				    inputs_dict['''decoder_attention_mask'''],
				)

				lowerCamelCase :			List[str]    		=model.init_cache(decoder_input_ids.shape[0]      ,  __lowercase      ,  __lowercase )
				lowerCamelCase :			List[str]    		=jnp.ones((decoder_input_ids.shape[0], max_decoder_length)      ,  dtype='''i4''' )

				lowerCamelCase :			Union[str, Any]    		=jnp.broadcast_to(
				    jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]      ,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)      ,  )
				lowerCamelCase :			Optional[int]    		=model.decode(
				    decoder_input_ids[:, :-1]      ,  __lowercase      ,  decoder_attention_mask=__lowercase      ,  past_key_values=__lowercase      ,  decoder_position_ids=__lowercase      ,  )

				lowerCamelCase :			str    		=jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]      ,  dtype='''i4''' )
				lowerCamelCase :			int    		=model.decode(
				    decoder_input_ids[:, -1:]      ,  __lowercase      ,  decoder_attention_mask=__lowercase      ,  past_key_values=outputs_cache.past_key_values      ,  decoder_position_ids=__lowercase      ,  )

				lowerCamelCase :			List[str]    		=model.decode(__lowercase      ,  __lowercase )

				lowerCamelCase :			Any    		=np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
				self.parent.assertTrue(diff < 1e-3      ,  msg=F"Max diff is {diff}" )







		def       __lowercase (		self      ,  __lowercase      ,  __lowercase      ,  __lowercase )					-> Tuple:
				lowerCamelCase :			Optional[Any]    		=2_0
				lowerCamelCase :			Union[str, Any]    		=model_class_name(__lowercase )

				lowerCamelCase :			Union[str, Any]    		=model.encode(inputs_dict['''input_ids'''] )

				lowerCamelCase		, lowerCamelCase :			str    		=(
				    inputs_dict['''decoder_input_ids'''],
				    inputs_dict['''decoder_attention_mask'''],
				)

				lowerCamelCase :			Optional[int]    		=jnp.concatenate(
				    [
				        decoder_attention_mask,
				        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ),
				    ]      ,  axis=-1      ,  )

				lowerCamelCase :			int    		=model.init_cache(decoder_input_ids.shape[0]      ,  __lowercase      ,  __lowercase )
				lowerCamelCase :			Dict    		=jnp.broadcast_to(
				    jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]      ,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)      ,  )

				lowerCamelCase :			int    		=model.decode(
				    decoder_input_ids[:, :-1]      ,  __lowercase      ,  decoder_attention_mask=__lowercase      ,  past_key_values=__lowercase      ,  decoder_position_ids=__lowercase      ,  )
				lowerCamelCase :			Optional[int]    		=jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]      ,  dtype='''i4''' )
				lowerCamelCase :			Optional[int]    		=model.decode(
				    decoder_input_ids[:, -1:]      ,  __lowercase      ,  past_key_values=outputs_cache.past_key_values      ,  decoder_attention_mask=__lowercase      ,  decoder_position_ids=__lowercase      ,  )

				lowerCamelCase :			List[str]    		=model.decode(__lowercase      ,  __lowercase      ,  decoder_attention_mask=__lowercase )

				lowerCamelCase :			Optional[Any]    		=np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
				self.parent.assertTrue(diff < 1e-3      ,  msg=F"Max diff is {diff}" )

@require_flax
class 							snake_case_		(      unittest.TestCase):
		lowerCamelCase     :str							=  99







		def       __lowercase (		self )					-> str:
				lowerCamelCase :			Tuple    		=np.array(
				    [
				        [7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2],
				        [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2],
				        [5, 9_7, 1_7, 3_9, 9_4, 4_0, 2],
				        [7_6, 8_3, 9_4, 2_5, 7_0, 7_8, 2],
				        [8_7, 5_9, 4_1, 3_5, 4_8, 6_6, 2],
				        [5_5, 1_3, 1_6, 5_8, 5, 2, 1],  # note padding
				        [6_4, 2_7, 3_1, 5_1, 1_2, 7_5, 2],
				        [5_2, 6_4, 8_6, 1_7, 8_3, 3_9, 2],
				        [4_8, 6_1, 9, 2_4, 7_1, 8_2, 2],
				        [2_6, 1, 6_0, 4_8, 2_2, 1_3, 2],
				        [2_1, 5, 6_2, 2_8, 1_4, 7_6, 2],
				        [4_5, 9_8, 3_7, 8_6, 5_9, 4_8, 2],
				        [7_0, 7_0, 5_0, 9, 2_8, 0, 2],
				    ]      ,  dtype=np.intaa      ,  )

				lowerCamelCase :			Optional[int]    		=input_ids.shape[0]
				lowerCamelCase :			Optional[int]    		=MBartConfig(
				    vocab_size=self.vocab_size      ,  d_model=2_4      ,  encoder_layers=2      ,  decoder_layers=2      ,  encoder_attention_heads=2      ,  decoder_attention_heads=2      ,  encoder_ffn_dim=3_2      ,  decoder_ffn_dim=3_2      ,  max_position_embeddings=4_8      ,  eos_token_id=2      ,  pad_token_id=1      ,  bos_token_id=0      ,  )
				return config, input_ids, batch_size







		def       __lowercase (		self )					-> Optional[int]:
				lowerCamelCase		, lowerCamelCase		, lowerCamelCase :			str    		=self._get_config_and_data()
				lowerCamelCase :			Union[str, Any]    		=FlaxMBartForSequenceClassification(__lowercase )
				lowerCamelCase :			int    		=model(input_ids=__lowercase      ,  decoder_input_ids=__lowercase )
				lowerCamelCase :			Dict    		=(batch_size, config.num_labels)
				self.assertEqual(outputs['''logits'''].shape      ,  __lowercase )







		def       __lowercase (		self )					-> str:
				lowerCamelCase		, lowerCamelCase		, lowerCamelCase :			Any    		=self._get_config_and_data()
				lowerCamelCase :			List[Any]    		=FlaxMBartForQuestionAnswering(__lowercase )
				lowerCamelCase :			Union[str, Any]    		=model(input_ids=__lowercase )

				self.assertEqual(outputs['''start_logits'''].shape      ,  input_ids.shape )
				self.assertEqual(outputs['''end_logits'''].shape      ,  input_ids.shape )







		def       __lowercase (		self )					-> List[str]:
				lowerCamelCase		, lowerCamelCase		, lowerCamelCase :			Union[str, Any]    		=self._get_config_and_data()
				lowerCamelCase :			Any    		=FlaxMBartForConditionalGeneration(__lowercase )
				lowerCamelCase :			Any    		=lm_model(input_ids=__lowercase )
				lowerCamelCase :			List[str]    		=(batch_size, input_ids.shape[1], config.vocab_size)
				self.assertEqual(outputs['''logits'''].shape      ,  __lowercase )







		def       __lowercase (		self )					-> Tuple:
				lowerCamelCase :			List[str]    		=MBartConfig(
				    vocab_size=self.vocab_size      ,  d_model=1_4      ,  encoder_layers=2      ,  decoder_layers=2      ,  encoder_attention_heads=2      ,  decoder_attention_heads=2      ,  encoder_ffn_dim=8      ,  decoder_ffn_dim=8      ,  max_position_embeddings=4_8      ,  )
				lowerCamelCase :			int    		=FlaxMBartForConditionalGeneration(__lowercase )
				lowerCamelCase :			str    		=np.array([[7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2], [6_8, 3_4, 2_6, 5_8, 3_0, 2, 1]]      ,  dtype=np.intaa )
				lowerCamelCase :			str    		=np.array([[8_2, 7_1, 8_2, 1_8, 2], [5_8, 6_8, 2, 1, 1]]      ,  dtype=np.intaa )
				lowerCamelCase :			Any    		=lm_model(input_ids=__lowercase      ,  decoder_input_ids=__lowercase )
				lowerCamelCase :			List[str]    		=(*summary.shape, config.vocab_size)
				self.assertEqual(outputs['''logits'''].shape      ,  __lowercase )







		def       __lowercase (		self )					-> int:
				lowerCamelCase :			List[str]    		=np.array([[7_1, 8_2, 1_8, 3_3, 2, 1, 1], [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2]]      ,  dtype=np.intaa )
				lowerCamelCase :			List[str]    		=shift_tokens_right(__lowercase      ,  1 )
				lowerCamelCase :			str    		=np.equal(__lowercase      ,  1 ).astype(np.floataa ).sum()
				lowerCamelCase :			List[str]    		=np.equal(__lowercase      ,  1 ).astype(np.floataa ).sum()
				self.assertEqual(shifted.shape      ,  input_ids.shape )
				self.assertEqual(__lowercase      ,  n_pad_before - 1 )
				self.assertTrue(np.equal(shifted[:, 0]      ,  2 ).all() )

@require_flax
class 							snake_case_		(      _A    ,       unittest.TestCase    ,       _A):
		lowerCamelCase     :List[str]							=  True
		lowerCamelCase     :Optional[int]							=  (
		    (
		        FlaxMBartModel,
		        FlaxMBartForConditionalGeneration,
		        FlaxMBartForSequenceClassification,
		        FlaxMBartForQuestionAnswering,
		    )
		    if is_flax_available()
		    else ()
		)
		lowerCamelCase     :Optional[int]							=  (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()







		def       __lowercase (		self )					-> Dict:
				lowerCamelCase :			List[Any]    		=FlaxMBartModelTester(self )







		def       __lowercase (		self )					-> Tuple:
				lowerCamelCase		, lowerCamelCase :			Any    		=self.model_tester.prepare_config_and_inputs()
				for model_class in self.all_model_classes:
						self.model_tester.check_use_cache_forward(__lowercase      ,  __lowercase      ,  __lowercase )







		def       __lowercase (		self )					-> Union[str, Any]:
				lowerCamelCase		, lowerCamelCase :			str    		=self.model_tester.prepare_config_and_inputs()
				for model_class in self.all_model_classes:
						self.model_tester.check_use_cache_forward_with_attn_mask(__lowercase      ,  __lowercase      ,  __lowercase )







		def       __lowercase (		self )					-> Optional[Any]:
				lowerCamelCase		, lowerCamelCase :			Optional[Any]    		=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						with self.subTest(model_class.__name__ ):
								lowerCamelCase :			Tuple    		=self._prepare_for_class(__lowercase      ,  __lowercase )
								lowerCamelCase :			Any    		=model_class(__lowercase )

								@jax.jit
								def encode_jitted(__lowercase      ,  __lowercase=None      ,  **__lowercase ):
										return model.encode(input_ids=__lowercase      ,  attention_mask=__lowercase )

								with self.subTest('''JIT Enabled''' ):
										lowerCamelCase :			Dict    		=encode_jitted(**__lowercase ).to_tuple()

								with self.subTest('''JIT Disabled''' ):
										with jax.disable_jit():
												lowerCamelCase :			str    		=encode_jitted(**__lowercase ).to_tuple()

								self.assertEqual(len(__lowercase )      ,  len(__lowercase ) )
								for jitted_output, output in zip(__lowercase      ,  __lowercase ):
										self.assertEqual(jitted_output.shape      ,  output.shape )







		def       __lowercase (		self )					-> int:
				lowerCamelCase		, lowerCamelCase :			List[Any]    		=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						with self.subTest(model_class.__name__ ):
								lowerCamelCase :			int    		=model_class(__lowercase )
								lowerCamelCase :			Dict    		=model.encode(inputs_dict['''input_ids''']      ,  inputs_dict['''attention_mask'''] )

								lowerCamelCase :			str    		={
								    '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
								    '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
								    '''encoder_outputs''': encoder_outputs,
								}

								@jax.jit
								def decode_jitted(__lowercase      ,  __lowercase      ,  __lowercase ):
										return model.decode(
										    decoder_input_ids=__lowercase      ,  decoder_attention_mask=__lowercase      ,  encoder_outputs=__lowercase      ,  )

								with self.subTest('''JIT Enabled''' ):
										lowerCamelCase :			Dict    		=decode_jitted(**__lowercase ).to_tuple()

								with self.subTest('''JIT Disabled''' ):
										with jax.disable_jit():
												lowerCamelCase :			List[Any]    		=decode_jitted(**__lowercase ).to_tuple()

								self.assertEqual(len(__lowercase )      ,  len(__lowercase ) )
								for jitted_output, output in zip(__lowercase      ,  __lowercase ):
										self.assertEqual(jitted_output.shape      ,  output.shape )







		@slow
		def       __lowercase (		self )					-> Optional[Any]:
				for model_class_name in self.all_model_classes:
						lowerCamelCase :			Dict    		=model_class_name.from_pretrained('''facebook/mbart-large-cc25'''      ,  from_pt=__lowercase )
						# FlaxMBartForSequenceClassification expects eos token in input_ids
						lowerCamelCase :			Optional[int]    		=np.ones((1, 1) ) * model.config.eos_token_id
						lowerCamelCase :			Optional[int]    		=model(__lowercase )
						self.assertIsNotNone(__lowercase )

@require_flax
@require_sentencepiece
@require_tokenizers
class 							snake_case_		(      unittest.TestCase):
		lowerCamelCase     :int							=  [
		    " UN Chief Says There Is No Military Solution in Syria",
		]
		lowerCamelCase     :Optional[Any]							=  [
		    "Şeful ONU declară că nu există o soluţie militară în Siria",
		]
		lowerCamelCase     :str							=  "facebook/mbart-large-en-ro"







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







		@cached_property
		def       __lowercase (		self )					-> Optional[int]:
				lowerCamelCase :			Dict    		=FlaxMBartForConditionalGeneration.from_pretrained(self.model_name      ,  from_pt=__lowercase )
				return model







		def       __lowercase (		self      ,  **__lowercase )					-> Tuple:
				lowerCamelCase :			str    		=self.translate_src_text(**__lowercase )
				self.assertListEqual(self.expected_text      ,  __lowercase )







		def       __lowercase (		self      ,  **__lowercase )					-> Dict:
				lowerCamelCase :			int    		=self.tokenizer(self.src_text      ,  **__lowercase      ,  return_tensors='''np''' )
				lowerCamelCase :			str    		=self.model.generate(
				    model_inputs.input_ids      ,  attention_mask=model_inputs.attention_mask      ,  decoder_start_token_id=self.tokenizer.lang_code_to_id['''ro_RO''']      ,  early_stopping=__lowercase      ,  num_beams=2      ,  ).sequences
				lowerCamelCase :			int    		=self.tokenizer.batch_decode(__lowercase      ,  skip_special_tokens=__lowercase )
				return generated_words







		@slow
		def       __lowercase (		self )					-> Dict:
				self._assert_generated_batch_equal_expected()








def        A__						(							SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_				,							SCREAMING_SNAKE_CASE_		) ->  Dict:
		assert b != 0, "This cannot accept modulo that is == 0"
		if n == 0:
				return 1

		if n % 2 == 1:
				return (bin_exp_mod(SCREAMING_SNAKE_CASE_				,							n - 1				,							SCREAMING_SNAKE_CASE_		) * a) % b

		lowerCamelCase :			Tuple    		=bin_exp_mod(SCREAMING_SNAKE_CASE_				,							n / 2				,							SCREAMING_SNAKE_CASE_		)
		return (r * r) % b


if __name__ == "__main__":
				try:
								snake_case_				=      int(input('''Enter Base : ''').strip())
								snake_case_				=      int(input('''Enter Power : ''').strip())
								snake_case_				=      int(input('''Enter Modulo : ''').strip())
				except ValueError:
								print('''Invalid literal for integer''')

				print(bin_exp_mod(BASE, POWER, MODULO))

