import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotSmallConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

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
      A   :     int       =				"platform"

      import jax
      import jax.numpy as jnp

      from transformers.models.blenderbot_small.modeling_flax_blenderbot_small import (
          FlaxBlenderbotSmallForConditionalGeneration,
          FlaxBlenderbotSmallModel,
          shift_tokens_right,
      )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					__UpperCamelCase=None   ,					):
      if attention_mask is None:
            SCREAMING_SNAKE_CASE_      =     np.where(input_ids != config.pad_token_id   ,					1   ,					0 )
      if decoder_attention_mask is None:
            SCREAMING_SNAKE_CASE_      =     np.where(decoder_input_ids != config.pad_token_id   ,					1   ,					0 )
      if head_mask is None:
            SCREAMING_SNAKE_CASE_      =     np.ones((config.encoder_layers, config.encoder_attention_heads) )
      if decoder_head_mask is None:
            SCREAMING_SNAKE_CASE_      =     np.ones((config.decoder_layers, config.decoder_attention_heads) )
      if cross_attn_head_mask is None:
            SCREAMING_SNAKE_CASE_      =     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": attention_mask,
      }


class      lowerCamelCase    :
  """simple docstring"""







  def __init__(							self       :				List[Any]     ,   __magic_name__       :				Dict     ,   __magic_name__       :				str=13     ,   __magic_name__       :				Dict=7     ,   __magic_name__       :				Optional[int]=True     ,   __magic_name__       :				List[str]=False     ,   __magic_name__       :				Tuple=99     ,   __magic_name__       :				Any=16     ,   __magic_name__       :				Union[str, Any]=2     ,   __magic_name__       :				Any=4     ,   __magic_name__       :				Union[str, Any]=4     ,   __magic_name__       :				List[str]="gelu"     ,   __magic_name__       :				Dict=0.1     ,   __magic_name__       :				Tuple=0.1     ,   __magic_name__       :				str=32     ,   __magic_name__       :				Union[str, Any]=2     ,   __magic_name__       :				Optional[int]=1     ,   __magic_name__       :				Union[str, Any]=0     ,   __magic_name__       :				int=0.02     ,   )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     parent
        SCREAMING_SNAKE_CASE_      =     batch_size
        SCREAMING_SNAKE_CASE_      =     seq_length
        SCREAMING_SNAKE_CASE_      =     is_training
        SCREAMING_SNAKE_CASE_      =     use_labels
        SCREAMING_SNAKE_CASE_      =     vocab_size
        SCREAMING_SNAKE_CASE_      =     hidden_size
        SCREAMING_SNAKE_CASE_      =     num_hidden_layers
        SCREAMING_SNAKE_CASE_      =     num_attention_heads
        SCREAMING_SNAKE_CASE_      =     intermediate_size
        SCREAMING_SNAKE_CASE_      =     hidden_act
        SCREAMING_SNAKE_CASE_      =     hidden_dropout_prob
        SCREAMING_SNAKE_CASE_      =     attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE_      =     max_position_embeddings
        SCREAMING_SNAKE_CASE_      =     eos_token_id
        SCREAMING_SNAKE_CASE_      =     pad_token_id
        SCREAMING_SNAKE_CASE_      =     bos_token_id
        SCREAMING_SNAKE_CASE_      =     initializer_range







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

        SCREAMING_SNAKE_CASE_      =     shift_tokens_right(__magic_name__     ,   1     ,   2      )

        SCREAMING_SNAKE_CASE_      =     BlenderbotSmallConfig(
            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     ,   initializer_range=self.initializer_range     ,   use_cache=__magic_name__     ,   )
        SCREAMING_SNAKE_CASE_      =     prepare_blenderbot_inputs_dict(__magic_name__     ,   __magic_name__     ,   __magic_name__      )
        return config, inputs_dict







  def       __A   (							self       :				List[str]      )     ->		int:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.prepare_config_and_inputs()
        return config, inputs_dict







  def       __A   (							self       :				Optional[int]     ,   __magic_name__       :				Any     ,   __magic_name__       :				List[str]     ,   __magic_name__       :				List[Any]      )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     20
        SCREAMING_SNAKE_CASE_      =     model_class_name(__magic_name__      )

        SCREAMING_SNAKE_CASE_      =     model.encode(inputs_dict["input_ids"]      )

        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     (
            inputs_dict["decoder_input_ids"],
            inputs_dict["decoder_attention_mask"],
        )

        SCREAMING_SNAKE_CASE_      =     model.init_cache(decoder_input_ids.shape[0]     ,   __magic_name__     ,   __magic_name__      )
        SCREAMING_SNAKE_CASE_      =     jnp.ones((decoder_input_ids.shape[0], max_decoder_length)     ,   dtype="i4"      )

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

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

        SCREAMING_SNAKE_CASE_      =     model.decode(__magic_name__     ,   __magic_name__      )

        SCREAMING_SNAKE_CASE_      =     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       :				Optional[Any]     ,   __magic_name__       :				Union[str, Any]     ,   __magic_name__       :				List[Any]     ,   __magic_name__       :				Tuple      )     ->		Optional[Any]:
        SCREAMING_SNAKE_CASE_      =     20
        SCREAMING_SNAKE_CASE_      =     model_class_name(__magic_name__      )

        SCREAMING_SNAKE_CASE_      =     model.encode(inputs_dict["input_ids"]      )

        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     (
            inputs_dict["decoder_input_ids"],
            inputs_dict["decoder_attention_mask"],
        )

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

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

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

        SCREAMING_SNAKE_CASE_      =     model.decode(__magic_name__     ,   __magic_name__     ,   decoder_attention_mask=__magic_name__      )

        SCREAMING_SNAKE_CASE_      =     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    ):
  """simple docstring"""







  lowerCamelCase__   =  9_9







  def       __A   (							self       :				Dict      )     ->		Dict:
        SCREAMING_SNAKE_CASE_      =     np.array(
            [
                [71, 82, 18, 33, 46, 91, 2],
                [68, 34, 26, 58, 30, 82, 2],
                [5, 97, 17, 39, 94, 40, 2],
                [76, 83, 94, 25, 70, 78, 2],
                [87, 59, 41, 35, 48, 66, 2],
                [55, 13, 16, 58, 5, 2, 1],  # note padding
                [64, 27, 31, 51, 12, 75, 2],
                [52, 64, 86, 17, 83, 39, 2],
                [48, 61, 9, 24, 71, 82, 2],
                [26, 1, 60, 48, 22, 13, 2],
                [21, 5, 62, 28, 14, 76, 2],
                [45, 98, 37, 86, 59, 48, 2],
                [70, 70, 50, 9, 28, 0, 2],
            ]     ,   dtype=np.intaa     ,   )

        SCREAMING_SNAKE_CASE_      =     input_ids.shape[0]
        SCREAMING_SNAKE_CASE_      =     BlenderbotSmallConfig(
            vocab_size=self.vocab_size     ,   d_model=24     ,   encoder_layers=2     ,   decoder_layers=2     ,   encoder_attention_heads=2     ,   decoder_attention_heads=2     ,   encoder_ffn_dim=32     ,   decoder_ffn_dim=32     ,   max_position_embeddings=48     ,   eos_token_id=2     ,   pad_token_id=1     ,   bos_token_id=0     ,   )
        return config, input_ids, batch_size







  def       __A   (							self       :				Union[str, Any]      )     ->		Optional[Any]:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self._get_config_and_data()
        SCREAMING_SNAKE_CASE_      =     FlaxBlenderbotSmallForConditionalGeneration(__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     lm_model(input_ids=__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     (batch_size, input_ids.shape[1], config.vocab_size)
        self.assertEqual(outputs["logits"].shape     ,   __magic_name__      )







  def       __A   (							self       :				Optional[int]      )     ->		int:
        SCREAMING_SNAKE_CASE_      =     BlenderbotSmallConfig(
            vocab_size=self.vocab_size     ,   d_model=14     ,   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=48     ,   )
        SCREAMING_SNAKE_CASE_      =     FlaxBlenderbotSmallForConditionalGeneration(__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]     ,   dtype=np.intaa      )
        SCREAMING_SNAKE_CASE_      =     np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]     ,   dtype=np.intaa      )
        SCREAMING_SNAKE_CASE_      =     lm_model(input_ids=__magic_name__     ,   decoder_input_ids=__magic_name__      )
        SCREAMING_SNAKE_CASE_      =     (*summary.shape, config.vocab_size)
        self.assertEqual(outputs["logits"].shape     ,   __magic_name__      )







  def       __A   (							self       :				Optional[Any]      )     ->		Dict:
        SCREAMING_SNAKE_CASE_      =     np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]     ,   dtype=np.intaa      )
        SCREAMING_SNAKE_CASE_      =     shift_tokens_right(__magic_name__     ,   1     ,   2      )
        SCREAMING_SNAKE_CASE_      =     np.equal(__magic_name__     ,   1      ).astype(np.floataa      ).sum()
        SCREAMING_SNAKE_CASE_      =     np.equal(__magic_name__     ,   1      ).astype(np.floataa      ).sum()
        self.assertEqual(shifted.shape     ,   input_ids.shape      )
        self.assertEqual(__magic_name__     ,   n_pad_before - 1      )
        self.assertTrue(np.equal(shifted[:, 0]     ,   2      ).all()      )



@require_flax
class      lowerCamelCase    (SCREAMING_SNAKE_CASE__     ,					unittest.TestCase     ,					SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  True
  lowerCamelCase__   =  (
      (
          FlaxBlenderbotSmallModel,
          FlaxBlenderbotSmallForConditionalGeneration,
      )
      if is_flax_available()
      else ()
  )
  lowerCamelCase__   =  (FlaxBlenderbotSmallForConditionalGeneration,) if is_flax_available() else ()







  def       __A   (							self       :				Optional[Any]      )     ->		List[str]:
        SCREAMING_SNAKE_CASE_      =     FlaxBlenderbotSmallModelTester(self      )







  def       __A   (							self       :				List[Any]      )     ->		Tuple:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs()
        for model_class in self.all_model_classes:
              self.model_tester.check_use_cache_forward(__magic_name__     ,   __magic_name__     ,   __magic_name__      )







  def       __A   (							self       :				Optional[int]      )     ->		Dict:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     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(__magic_name__     ,   __magic_name__     ,   __magic_name__      )







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

        for model_class in self.all_model_classes:
              with self.subTest(model_class.__name__      ):
                    SCREAMING_SNAKE_CASE_      =     self._prepare_for_class(__magic_name__     ,   __magic_name__      )
                    SCREAMING_SNAKE_CASE_      =     model_class(__magic_name__      )

                    @jax.jit
                    def encode_jitted(__magic_name__       :				Dict     ,   __magic_name__       :				Tuple=None     ,   **__magic_name__       :				List[str]      ):
                          return model.encode(input_ids=__magic_name__     ,   attention_mask=__magic_name__      )

                    with self.subTest("JIT Enabled"      ):
                          SCREAMING_SNAKE_CASE_      =     encode_jitted(**__magic_name__      ).to_tuple()

                    with self.subTest("JIT Disabled"      ):
                          with jax.disable_jit():
                                SCREAMING_SNAKE_CASE_      =     encode_jitted(**__magic_name__      ).to_tuple()

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







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

        for model_class in self.all_model_classes:
              with self.subTest(model_class.__name__      ):
                    SCREAMING_SNAKE_CASE_      =     model_class(__magic_name__      )
                    SCREAMING_SNAKE_CASE_      =     model.encode(inputs_dict["input_ids"]     ,   inputs_dict["attention_mask"]      )

                    SCREAMING_SNAKE_CASE_      =     {
                        "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(__magic_name__       :				List[Any]     ,   __magic_name__       :				str     ,   __magic_name__       :				List[Any]      ):
                          return model.decode(
                              decoder_input_ids=__magic_name__     ,   decoder_attention_mask=__magic_name__     ,   encoder_outputs=__magic_name__     ,   )

                    with self.subTest("JIT Enabled"      ):
                          SCREAMING_SNAKE_CASE_      =     decode_jitted(**__magic_name__      ).to_tuple()

                    with self.subTest("JIT Disabled"      ):
                          with jax.disable_jit():
                                SCREAMING_SNAKE_CASE_      =     decode_jitted(**__magic_name__      ).to_tuple()

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







  @slow
  def       __A   (							self       :				Tuple      )     ->		List[str]:
        for model_class_name in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      =     model_class_name.from_pretrained("facebook/blenderbot_small-90M"      )
              # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
              SCREAMING_SNAKE_CASE_      =     np.ones((1, 1)      ) * model.config.eos_token_id
              SCREAMING_SNAKE_CASE_      =     model(__magic_name__      )
              self.assertIsNotNone(__magic_name__      )



import math
from datetime import datetime, timedelta


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     year % 1_9
      SCREAMING_SNAKE_CASE_      =     year % 4
      SCREAMING_SNAKE_CASE_      =     year % 7
      SCREAMING_SNAKE_CASE_      =     math.floor(year / 1_0_0 )
      SCREAMING_SNAKE_CASE_      =     math.floor((1_3 + 8 * leap_day_inhibits) / 2_5 )
      SCREAMING_SNAKE_CASE_      =     leap_day_inhibits / 4
      SCREAMING_SNAKE_CASE_      =     (
          1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 3_0
      SCREAMING_SNAKE_CASE_      =     (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

      # days to be added to March 21
      SCREAMING_SNAKE_CASE_      =     (1_9 * metonic_cycle + secular_moon_shift) % 3_0

      # PHM -> Paschal Full Moon
      SCREAMING_SNAKE_CASE_      =     (
          2 * julian_leap_year
          + 4 * non_leap_year
          + 6 * days_to_add
          + century_starting_point
      ) % 7

      if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
            return datetime(__UpperCamelCase   ,					4   ,					1_9 )
      elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
            return datetime(__UpperCamelCase   ,					4   ,					1_8 )
      else:
            return datetime(__UpperCamelCase   ,					3   ,					2_2 ) + timedelta(
                days=int(days_to_add + days_from_phm_to_sunday ) )


if __name__ == "__main__":
      for year in (19_94, 20_00, 20_10, 20_21, 20_23):
            A   :     Dict       =				"will be" if year > datetime.now().year else "was"
            print(f"Easter in {year} {tense} {gauss_easter(year)}")


