import unittest

import numpy as np

from transformers import is_flax_available
from transformers.testing_utils import require_flax

from ..test_modeling_flax_common import ids_tensor


if is_flax_available():
  import jax
  import jax.numpy as jnp

  from transformers.generation import (
      FlaxForcedBOSTokenLogitsProcessor,
      FlaxForcedEOSTokenLogitsProcessor,
      FlaxLogitsProcessorList,
      FlaxMinLengthLogitsProcessor,
      FlaxTemperatureLogitsWarper,
      FlaxTopKLogitsWarper,
      FlaxTopPLogitsWarper,
  )
@require_flax
class    A_ (       unittest.TestCase ):

  def 		_UpperCAmelCase   (		self :      Any     ,							__SCREAMING_SNAKE_CASE :      int     ,							__SCREAMING_SNAKE_CASE :      int       ):
   __a       =  jnp.ones((batch_size, length)       ) / length
   return scores

  def 		_UpperCAmelCase   (		self :      Any       ):
   __a       =  None
   __a       =  20

   __a       =  self._get_uniform_logits(batch_size=2     ,							length=__SCREAMING_SNAKE_CASE       )

   # tweak scores to not be uniform anymore
   __a       =  scores.at[1, 5].set((1 / length) + 0.1       )  # peak, 1st batch
   __a       =  scores.at[1, 10].set((1 / length) - 0.4       )  # valley, 1st batch

   # compute softmax
   __a       =  jax.nn.softmax(__SCREAMING_SNAKE_CASE     ,							axis=-1       )

   __a       =  FlaxTemperatureLogitsWarper(temperature=0.5       )
   __a       =  FlaxTemperatureLogitsWarper(temperature=1.3       )

   __a       =  jax.nn.softmax(temp_dist_warper_sharper(__SCREAMING_SNAKE_CASE     ,							scores.copy()     ,							cur_len=__SCREAMING_SNAKE_CASE       )     ,							axis=-1       )
   __a       =  jax.nn.softmax(temp_dist_warper_smoother(__SCREAMING_SNAKE_CASE     ,							scores.copy()     ,							cur_len=__SCREAMING_SNAKE_CASE       )     ,							axis=-1       )

   # uniform distribution stays uniform
   self.assertTrue(jnp.allclose(probs[0, :]     ,							warped_prob_sharp[0, :]     ,							atol=1E-3       )       )
   self.assertTrue(jnp.allclose(probs[0, :]     ,							warped_prob_smooth[0, :]     ,							atol=1E-3       )       )

   # sharp peaks get higher, valleys get lower
   self.assertLess(probs[1, :].max()     ,							warped_prob_sharp[1, :].max()       )
   self.assertGreater(probs[1, :].min()     ,							warped_prob_sharp[1, :].min()       )

   # smooth peaks get lower, valleys get higher
   self.assertGreater(probs[1, :].max()     ,							warped_prob_smooth[1, :].max()       )
   self.assertLess(probs[1, :].min()     ,							warped_prob_smooth[1, :].min()       )

  def 		_UpperCAmelCase   (		self :      Tuple       ):
   __a       =  None
   __a       =  10
   __a       =  2

   # create ramp distribution
   __a       =  np.broadcast_to(np.arange(__SCREAMING_SNAKE_CASE       )[None, :]     ,							(batch_size, vocab_size)       ).copy()
   __a       =  ramp_logits[1:, : vocab_size // 2] + vocab_size

   __a       =  FlaxTopKLogitsWarper(3       )

   __a       =  top_k_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )

   # check that correct tokens are filtered
   self.assertListEqual(jnp.isinf(scores[0]       ).tolist()     ,							7 * [True] + 3 * [False]       )
   self.assertListEqual(jnp.isinf(scores[1]       ).tolist()     ,							2 * [True] + 3 * [False] + 5 * [True]       )

   # check special case
   __a       =  5
   __a       =  FlaxTopKLogitsWarper(top_k=1     ,							filter_value=0.0     ,							min_tokens_to_keep=3       )

   __a       =  np.broadcast_to(np.arange(__SCREAMING_SNAKE_CASE       )[None, :]     ,							(batch_size, length)       ).copy()
   __a       =  top_k_warp_safety_check(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )

   # min_tokens overwrites k: 3 tokens are kept => 2 tokens are nullified
   self.assertListEqual((scores == 0.0).sum(axis=-1       ).tolist()     ,							[2, 2]       )

  def 		_UpperCAmelCase   (		self :      str       ):
   __a       =  None
   __a       =  10
   __a       =  2

   # create distribution and take log (inverse to Softmax as taken in TopPLogitsWarper)
   __a       =  np.log(np.array([[0.3, 0.1, 0.1, 0.5], [0.15, 0.3, 0.3, 0.25]]       )       )

   __a       =  FlaxTopPLogitsWarper(0.8       )
   __a       =  np.exp(top_p_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )       )

   # dist should be filtered to keep min num values so that sum is >= top_p
   # exp (-inf) => 0
   __a       =  np.array([[0.3, 0.0, 0.0, 0.5], [0.0, 0.3, 0.3, 0.25]]       )
   self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							atol=1E-3       )       )

   # check edge cases with negative and extreme logits
   __a       =  np.broadcast_to(np.arange(__SCREAMING_SNAKE_CASE       )[None, :]     ,							(batch_size, vocab_size)       ).copy() - (
       vocab_size // 2
   )

   # make ramp_logits more extreme
   __a       =  ramp_logits[1] * 1_00.0

   # make sure at least 2 tokens are kept
   __a       =  FlaxTopPLogitsWarper(0.9     ,							min_tokens_to_keep=2     ,							filter_value=0.0       )
   __a       =  top_p_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )

   # first batch should keep three tokens, second batch would keep only 1, but due to `min_tokens_to_keep=2` keeps 2.
   self.assertListEqual((filtered_dist != 0.0).sum(axis=-1       ).tolist()     ,							[3, 2]       )

  def 		_UpperCAmelCase   (		self :      List[str]       ):
   __a       =  20
   __a       =  4
   __a       =  0

   __a       =  FlaxMinLengthLogitsProcessor(min_length=10     ,							eos_token_id=__SCREAMING_SNAKE_CASE       )

   # check that min length is applied at length 5
   __a       =  ids_tensor((batch_size, 20)     ,							vocab_size=20       )
   __a       =  5
   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  min_dist_processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   self.assertListEqual(scores_before_min_length[:, eos_token_id].tolist()     ,							4 * [-float("inf"       )]       )

   # check that min length is not applied anymore at length 15
   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  15
   __a       =  min_dist_processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   self.assertFalse(jnp.isinf(__SCREAMING_SNAKE_CASE       ).any()       )

  def 		_UpperCAmelCase   (		self :      Optional[Any]       ):
   __a       =  20
   __a       =  4
   __a       =  0

   __a       =  FlaxForcedBOSTokenLogitsProcessor(bos_token_id=__SCREAMING_SNAKE_CASE       )

   # check that all scores are -inf except the bos_token_id score
   __a       =  ids_tensor((batch_size, 1)     ,							vocab_size=20       )
   __a       =  1
   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  logits_processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   self.assertTrue(jnp.isneginf(scores[:, bos_token_id + 1 :]       ).all()       )
   self.assertListEqual(scores[:, bos_token_id].tolist()     ,							4 * [0]       )  # score for bos_token_id shold be zero

   # check that bos_token_id is not forced if current length is greater than 1
   __a       =  3
   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  logits_processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   self.assertFalse(jnp.isinf(__SCREAMING_SNAKE_CASE       ).any()       )

  def 		_UpperCAmelCase   (		self :      List[Any]       ):
   __a       =  20
   __a       =  4
   __a       =  0
   __a       =  5

   __a       =  FlaxForcedEOSTokenLogitsProcessor(max_length=__SCREAMING_SNAKE_CASE     ,							eos_token_id=__SCREAMING_SNAKE_CASE       )

   # check that all scores are -inf except the eos_token_id when max_length is reached
   __a       =  ids_tensor((batch_size, 4)     ,							vocab_size=20       )
   __a       =  4
   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  logits_processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   self.assertTrue(jnp.isneginf(scores[:, eos_token_id + 1 :]       ).all()       )
   self.assertListEqual(scores[:, eos_token_id].tolist()     ,							4 * [0]       )  # score for eos_token_id should be zero

   # check that eos_token_id is not forced if max_length is not reached
   __a       =  3
   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  logits_processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   self.assertFalse(jnp.isinf(__SCREAMING_SNAKE_CASE       ).any()       )

  def 		_UpperCAmelCase   (		self :      Optional[Any]       ):
   __a       =  4
   __a       =  10
   __a       =  15
   __a       =  2
   __a       =  1
   __a       =  15

   # dummy input_ids and scores
   __a       =  ids_tensor((batch_size, sequence_length)     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  input_ids.copy()

   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  scores.copy()

   # instantiate all dist processors
   __a       =  FlaxTemperatureLogitsWarper(temperature=0.5       )
   __a       =  FlaxTopKLogitsWarper(3       )
   __a       =  FlaxTopPLogitsWarper(0.8       )

   # instantiate all logits processors
   __a       =  FlaxMinLengthLogitsProcessor(min_length=10     ,							eos_token_id=__SCREAMING_SNAKE_CASE       )
   __a       =  FlaxForcedBOSTokenLogitsProcessor(bos_token_id=__SCREAMING_SNAKE_CASE       )
   __a       =  FlaxForcedEOSTokenLogitsProcessor(max_length=__SCREAMING_SNAKE_CASE     ,							eos_token_id=__SCREAMING_SNAKE_CASE       )

   __a       =  10

   # no processor list
   __a       =  temp_dist_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   __a       =  top_k_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   __a       =  top_p_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   __a       =  min_dist_proc(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   __a       =  bos_dist_proc(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
   __a       =  eos_dist_proc(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )

   # with processor list
   __a       =  FlaxLogitsProcessorList(
       [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]       )
   __a       =  processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )

   # scores should be equal
   self.assertTrue(jnp.allclose(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							atol=1E-3       )       )

   # input_ids should never be changed
   self.assertListEqual(input_ids.tolist()     ,							input_ids_comp.tolist()       )

  def 		_UpperCAmelCase   (		self :      Tuple       ):
   __a       =  4
   __a       =  10
   __a       =  15
   __a       =  2
   __a       =  1
   __a       =  15

   # dummy input_ids and scores
   __a       =  ids_tensor((batch_size, sequence_length)     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  input_ids.copy()

   __a       =  self._get_uniform_logits(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  scores.copy()

   # instantiate all dist processors
   __a       =  FlaxTemperatureLogitsWarper(temperature=0.5       )
   __a       =  FlaxTopKLogitsWarper(3       )
   __a       =  FlaxTopPLogitsWarper(0.8       )

   # instantiate all logits processors
   __a       =  FlaxMinLengthLogitsProcessor(min_length=10     ,							eos_token_id=__SCREAMING_SNAKE_CASE       )
   __a       =  FlaxForcedBOSTokenLogitsProcessor(bos_token_id=__SCREAMING_SNAKE_CASE       )
   __a       =  FlaxForcedEOSTokenLogitsProcessor(max_length=__SCREAMING_SNAKE_CASE     ,							eos_token_id=__SCREAMING_SNAKE_CASE       )

   __a       =  10

   # no processor list
   def run_no_processor_list(__SCREAMING_SNAKE_CASE :      Optional[int]     ,							__SCREAMING_SNAKE_CASE :      Optional[Any]     ,							__SCREAMING_SNAKE_CASE :      Any       ):
    __a       =  temp_dist_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
    __a       =  top_k_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
    __a       =  top_p_warp(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
    __a       =  min_dist_proc(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
    __a       =  bos_dist_proc(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
    __a       =  eos_dist_proc(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
    return scores

   # with processor list
   def run_processor_list(__SCREAMING_SNAKE_CASE :      List[Any]     ,							__SCREAMING_SNAKE_CASE :      List[Any]     ,							__SCREAMING_SNAKE_CASE :      int       ):
    __a       =  FlaxLogitsProcessorList(
        [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]       )
    __a       =  processor(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							cur_len=__SCREAMING_SNAKE_CASE       )
    return scores

   __a       =  jax.jit(__SCREAMING_SNAKE_CASE       )
   __a       =  jax.jit(__SCREAMING_SNAKE_CASE       )

   __a       =  jitted_run_no_processor_list(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )
   __a       =  jitted_run_processor_list(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE       )

   # scores should be equal
   self.assertTrue(jnp.allclose(__SCREAMING_SNAKE_CASE     ,							__SCREAMING_SNAKE_CASE     ,							atol=1E-3       )       )

   # input_ids should never be changed
   self.assertListEqual(input_ids.tolist()     ,							input_ids_comp.tolist()       )



# Function to print upper half of diamond (pyramid)



def   __A		(			_A					):



 """simple docstring"""


 for i in range(0							,				_A					):
  for _ in range(0							,				n - i - 1					):  # printing spaces
   print(" "							,				end=""					)
  for _ in range(0							,				i + 1					):  # printing stars
   print("* "							,				end=""					)
  print()



def   __A		(			_A					):



 """simple docstring"""


 for i in range(_A							,				0							,				-1					):
  for _ in range(_A							,				0							,				-1					):  # printing stars
   print("* "							,				end=""					)
  print()
  for _ in range(n - i + 1							,				0							,				-1					):  # printing spaces
   print(" "							,				end=""					)



def   __A		(			_A					):



 """simple docstring"""


 if n <= 0:
  print("       ...       ....        nothing printing :("					)
  return
 floyd(_A					)  # upper half
 reverse_floyd(_A					)  # lower half


if __name__ == "__main__":
  print(R"""| /\ | |- |  |-  |--| |\  /| |-""")
  print(R"""|/  \| |- |_ |_  |__| | \/ | |_""")
  SCREAMING_SNAKE_CASE :	Tuple							     =		1
  while K:
    SCREAMING_SNAKE_CASE :	Tuple							     =		int(input("""enter the number and , and see the magic : """))
    print()
    pretty_print(user_number)
    SCREAMING_SNAKE_CASE :	Optional[int]							     =		int(input("""press 0 to exit... and 1 to continue..."""))

  print("""Good Bye...""")


