


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
  UpperCAmelCase__     			=							'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        UpperCAmelCase_      (							__snake_case  ,		__snake_case  ,		__snake_case=None  ,		__snake_case=None  ,		__snake_case=None  ,		__snake_case=None  ,		__snake_case=None  ,		__snake_case=None  ,		)  ->    Any:







     """simple docstring"""


     if attention_mask is None:
          _lowercase							   =np.where(input_ids != config.pad_token_id  ,		1  ,		0		)
     if decoder_attention_mask is None:
          _lowercase							   =np.where(decoder_input_ids != config.pad_token_id  ,		1  ,		0		)
     if head_mask is None:
          _lowercase							   =np.ones((config.encoder_layers, config.encoder_attention_heads)		)
     if decoder_head_mask is None:
          _lowercase							   =np.ones((config.decoder_layers, config.decoder_attention_heads)		)
     if cross_attn_head_mask is None:
          _lowercase							   =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    lowerCamelCase__     ( unittest.TestCase):





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





     def   __A      (self )  ->     Optional[int]:
          _lowercase							   =np.clip(ids_tensor([self.batch_size, self.seq_length - 1]	,  self.vocab_size )	,  3	,  self.vocab_size )
          _lowercase							   =np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)	,  dtype=np.intaa ))	,  -1 )

          _lowercase							   =shift_tokens_right(UpperCAmelCase	,  1 )

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





     def   __A      (self )  ->     Any:
          _lowercase   ,					_lowercase							   =self.prepare_config_and_inputs()
          return config, inputs_dict





     def   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase )  ->     List[str]:
          _lowercase							   =2_0
          _lowercase							   =model_class_name(UpperCAmelCase )

          _lowercase							   =model.encode(inputs_dict['''input_ids'''] )

          _lowercase   ,					_lowercase							   =(
              inputs_dict['''decoder_input_ids'''],
              inputs_dict['''decoder_attention_mask'''],
          )

          _lowercase							   =model.init_cache(decoder_input_ids.shape[0]	,  UpperCAmelCase	,  UpperCAmelCase )
          _lowercase							   =jnp.ones((decoder_input_ids.shape[0], max_decoder_length)	,  dtype='''i4''' )

          _lowercase							   =jnp.broadcast_to(
              jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]	,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)	,  )
          _lowercase							   =model.decode(
              decoder_input_ids[:, :-1]	,  UpperCAmelCase	,  decoder_attention_mask=UpperCAmelCase	,  past_key_values=UpperCAmelCase	,  decoder_position_ids=UpperCAmelCase	,  )

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

          _lowercase							   =model.decode(UpperCAmelCase	,  UpperCAmelCase )

          _lowercase							   =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   __A      (self	,  UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase )  ->     List[str]:
          _lowercase							   =2_0
          _lowercase							   =model_class_name(UpperCAmelCase )

          _lowercase							   =model.encode(inputs_dict['''input_ids'''] )

          _lowercase   ,					_lowercase							   =(
              inputs_dict['''decoder_input_ids'''],
              inputs_dict['''decoder_attention_mask'''],
          )

          _lowercase							   =jnp.concatenate(
              [
                  decoder_attention_mask,
                  jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ),
              ]	,  axis=-1	,  )

          _lowercase							   =model.init_cache(decoder_input_ids.shape[0]	,  UpperCAmelCase	,  UpperCAmelCase )
          _lowercase							   =jnp.broadcast_to(
              jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]	,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)	,  )

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

          _lowercase							   =model.decode(UpperCAmelCase	,  UpperCAmelCase	,  decoder_attention_mask=UpperCAmelCase )

          _lowercase							   =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    lowerCamelCase__     ( unittest.TestCase):
     SCREAMING_SNAKE_CASE__       =    99





     def   __A      (self )  ->     Tuple:
          _lowercase							   =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	,  )

          _lowercase							   =input_ids.shape[0]
          _lowercase							   =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   __A      (self )  ->     List[str]:
          _lowercase   ,					_lowercase   ,					_lowercase							   =self._get_config_and_data()
          _lowercase							   =FlaxMBartForSequenceClassification(UpperCAmelCase )
          _lowercase							   =model(input_ids=UpperCAmelCase	,  decoder_input_ids=UpperCAmelCase )
          _lowercase							   =(batch_size, config.num_labels)
          self.assertEqual(outputs['''logits'''].shape	,  UpperCAmelCase )





     def   __A      (self )  ->     Optional[int]:
          _lowercase   ,					_lowercase   ,					_lowercase							   =self._get_config_and_data()
          _lowercase							   =FlaxMBartForQuestionAnswering(UpperCAmelCase )
          _lowercase							   =model(input_ids=UpperCAmelCase )

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





     def   __A      (self )  ->     Dict:
          _lowercase   ,					_lowercase   ,					_lowercase							   =self._get_config_and_data()
          _lowercase							   =FlaxMBartForConditionalGeneration(UpperCAmelCase )
          _lowercase							   =lm_model(input_ids=UpperCAmelCase )
          _lowercase							   =(batch_size, input_ids.shape[1], config.vocab_size)
          self.assertEqual(outputs['''logits'''].shape	,  UpperCAmelCase )





     def   __A      (self )  ->     List[str]:
          _lowercase							   =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	,  )
          _lowercase							   =FlaxMBartForConditionalGeneration(UpperCAmelCase )
          _lowercase							   =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 )
          _lowercase							   =np.array([[8_2, 7_1, 8_2, 1_8, 2], [5_8, 6_8, 2, 1, 1]]	,  dtype=np.intaa )
          _lowercase							   =lm_model(input_ids=UpperCAmelCase	,  decoder_input_ids=UpperCAmelCase )
          _lowercase							   =(*summary.shape, config.vocab_size)
          self.assertEqual(outputs['''logits'''].shape	,  UpperCAmelCase )





     def   __A      (self )  ->     List[str]:
          _lowercase							   =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 )
          _lowercase							   =shift_tokens_right(UpperCAmelCase	,  1 )
          _lowercase							   =np.equal(UpperCAmelCase	,  1 ).astype(np.floataa ).sum()
          _lowercase							   =np.equal(UpperCAmelCase	,  1 ).astype(np.floataa ).sum()
          self.assertEqual(shifted.shape	,  input_ids.shape )
          self.assertEqual(UpperCAmelCase	,  n_pad_before - 1 )
          self.assertTrue(np.equal(shifted[:, 0]	,  2 ).all() )







@require_flax
class    lowerCamelCase__     ( UpperCAmelCase_     ,							unittest.TestCase     ,							UpperCAmelCase_):
     SCREAMING_SNAKE_CASE__       =    True
     SCREAMING_SNAKE_CASE__       =    (
         (
             FlaxMBartModel,
             FlaxMBartForConditionalGeneration,
             FlaxMBartForSequenceClassification,
             FlaxMBartForQuestionAnswering,
         )
         if is_flax_available()
         else ()
     )
     SCREAMING_SNAKE_CASE__       =    (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()





     def   __A      (self )  ->     Optional[int]:
          _lowercase							   =FlaxMBartModelTester(self )





     def   __A      (self )  ->     Dict:
          _lowercase   ,					_lowercase							   =self.model_tester.prepare_config_and_inputs()
          for model_class in self.all_model_classes:
               self.model_tester.check_use_cache_forward(UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase )





     def   __A      (self )  ->     Optional[Any]:
          _lowercase   ,					_lowercase							   =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(UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase )





     def   __A      (self )  ->     List[Any]:
          _lowercase   ,					_lowercase							   =self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__ ):
                    _lowercase							   =self._prepare_for_class(UpperCAmelCase	,  UpperCAmelCase )
                    _lowercase							   =model_class(UpperCAmelCase )

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

                    with self.subTest('''JIT Enabled''' ):
                         _lowercase							   =encode_jitted(**UpperCAmelCase ).to_tuple()

                    with self.subTest('''JIT Disabled''' ):
                         with jax.disable_jit():
                              _lowercase							   =encode_jitted(**UpperCAmelCase ).to_tuple()

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





     def   __A      (self )  ->     int:
          _lowercase   ,					_lowercase							   =self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               with self.subTest(model_class.__name__ ):
                    _lowercase							   =model_class(UpperCAmelCase )
                    _lowercase							   =model.encode(inputs_dict['''input_ids''']	,  inputs_dict['''attention_mask'''] )

                    _lowercase							   ={
                        '''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(UpperCAmelCase	,  UpperCAmelCase	,  UpperCAmelCase ):
                         return model.decode(
                             decoder_input_ids=UpperCAmelCase	,  decoder_attention_mask=UpperCAmelCase	,  encoder_outputs=UpperCAmelCase	,  )

                    with self.subTest('''JIT Enabled''' ):
                         _lowercase							   =decode_jitted(**UpperCAmelCase ).to_tuple()

                    with self.subTest('''JIT Disabled''' ):
                         with jax.disable_jit():
                              _lowercase							   =decode_jitted(**UpperCAmelCase ).to_tuple()

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





     @slow
     def   __A      (self )  ->     str:
          for model_class_name in self.all_model_classes:
               _lowercase							   =model_class_name.from_pretrained('''facebook/mbart-large-cc25'''	,  from_pt=UpperCAmelCase )
               # FlaxMBartForSequenceClassification expects eos token in input_ids
               _lowercase							   =np.ones((1, 1) ) * model.config.eos_token_id
               _lowercase							   =model(UpperCAmelCase )
               self.assertIsNotNone(UpperCAmelCase )







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





     @cached_property
     def   __A      (self )  ->     int:
          return AutoTokenizer.from_pretrained(self.model_name )





     @cached_property
     def   __A      (self )  ->     Dict:
          _lowercase							   =FlaxMBartForConditionalGeneration.from_pretrained(self.model_name	,  from_pt=UpperCAmelCase )
          return model





     def   __A      (self	,  **UpperCAmelCase )  ->     str:
          _lowercase							   =self.translate_src_text(**UpperCAmelCase )
          self.assertListEqual(self.expected_text	,  UpperCAmelCase )





     def   __A      (self	,  **UpperCAmelCase )  ->     Any:
          _lowercase							   =self.tokenizer(self.src_text	,  **UpperCAmelCase	,  return_tensors='''np''' )
          _lowercase							   =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=UpperCAmelCase	,  num_beams=2	,  ).sequences
          _lowercase							   =self.tokenizer.batch_decode(UpperCAmelCase	,  skip_special_tokens=UpperCAmelCase )
          return generated_words





     @slow
     def   __A      (self )  ->     List[str]:
          self._assert_generated_batch_equal_expected()





import requests

try:
  from django.contrib.auth import authenticate, login
  from django.shortcuts import redirect, render
except ImportError:
  UpperCAmelCase__     			=							UpperCAmelCase__     			=							UpperCAmelCase__     			=							UpperCAmelCase__     			=							print
def        UpperCAmelCase_      (							__snake_case		)  ->    List[str]:







 """simple docstring"""


 _lowercase							   ='''secretKey'''
 _lowercase							   ='''https://www.google.com/recaptcha/api/siteverify'''

 # when method is not POST, direct user to login page
 if request.method != "POST":
  return render(__snake_case  ,		'''login.html'''		)

 # from the frontend, get username, password, and client_key
 _lowercase							   =request.POST.get('''username'''		)
 _lowercase							   =request.POST.get('''password'''		)
 _lowercase							   =request.POST.get('''g-recaptcha-response'''		)

 # post recaptcha response to Google's recaptcha api
 _lowercase							   =requests.post(__snake_case  ,		data={'''secret''': secret_key, '''response''': client_key}		)
 # if the recaptcha api verified our keys
 if response.json().get('''success'''  ,		__snake_case		):
  # authenticate the user
  _lowercase							   =authenticate(__snake_case  ,		username=__snake_case  ,		password=__snake_case		)
  if user_in_database:
   login(__snake_case  ,		__snake_case		)
   return redirect('''/your-webpage'''		)
 return render(__snake_case  ,		'''login.html'''		)

