



from math import sqrt
def 		UpperCamelCase     (       snake_case__	:   int     )     ->					bool:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (
			    number >= 0
			), "'number' must been an int and positive"

			UpperCamelCase   :  Dict						     =     True

			# 0 and 1 are none primes.
			if number <= 1:
						UpperCamelCase   :  Optional[Any]						     =     False

			for divisor in range(2	,					int(round(sqrt(__SCREAMING_SNAKE_CASE     )     )     ) + 1     ):
						# if 'number' divisible by 'divisor' then sets 'status'
						# of false and break up the loop.
						if number % divisor == 0:
									UpperCamelCase   :  List[Any]						     =     False
									break

    # precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'status' must been from type bool"

			return status
def 		UpperCamelCase     (       snake_case__	:   Tuple     )     ->					Any:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (n > 2), "'N' must been an int and > 2"

			# beginList: contains all natural numbers from 2 up to N
			UpperCamelCase   :  Union[str, Any]						     =     list(range(2	,					n + 1     )     )

			UpperCamelCase   :  Any						     =     []  # this list will be returns.

			# actual sieve of erathostenes
			for i in range(len(__SCREAMING_SNAKE_CASE     )     ):
						for j in range(i + 1	,					len(__SCREAMING_SNAKE_CASE     )     ):
									if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
												UpperCamelCase   :  List[Any]						     =     0

    # filters actual prime numbers.
			UpperCamelCase   :  Optional[int]						     =     [x for x in begin_list if x != 0]

			# precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'ans' must been from type list"

			return ans
def 		UpperCamelCase     (       snake_case__	:   List[Any]     )     ->					Any:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (n > 2), "'N' must been an int and > 2"

			UpperCamelCase   :  Union[str, Any]						     =     []

			# iterates over all numbers between 2 up to N+1
			# if a number is prime then appends to list 'ans'
			for number in range(2	,					n + 1     ):
						if is_prime(__SCREAMING_SNAKE_CASE     ):
									ans.append(__SCREAMING_SNAKE_CASE     )

    # precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'ans' must been from type list"

			return ans
def 		UpperCamelCase     (       snake_case__	:   List[str]     )     ->					int:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and number >= 0, "'number' must been an int and >= 0"

			UpperCamelCase   :  Tuple						     =     []  # this list will be returns of the function.

			# potential prime number factors.

			UpperCamelCase   :  str						     =     2

			UpperCamelCase   :  Tuple						     =     number

			if number == 0 or number == 1:
						ans.append(__SCREAMING_SNAKE_CASE     )

			# if 'number' not prime then builds the prime factorization of 'number'
			elif not is_prime(__SCREAMING_SNAKE_CASE     ):
						while quotient != 1:
									if is_prime(__SCREAMING_SNAKE_CASE     ) and (quotient % factor == 0):
												ans.append(__SCREAMING_SNAKE_CASE     )
												quotient /= factor
									else:
												factor += 1

			else:
						ans.append(__SCREAMING_SNAKE_CASE     )

			# precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'ans' must been from type list"

			return ans
def 		UpperCamelCase     (       snake_case__	:   str     )     ->					Any:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			UpperCamelCase   :  Union[str, Any]						     =     0

			# prime factorization of 'number'
			UpperCamelCase   :  str						     =     prime_factorization(__SCREAMING_SNAKE_CASE     )

			UpperCamelCase   :  Dict						     =     max(__SCREAMING_SNAKE_CASE     )

			# precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'ans' must been from type int"

			return ans
def 		UpperCamelCase     (       snake_case__	:   Dict     )     ->					Optional[int]:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			UpperCamelCase   :  List[str]						     =     0

			# prime factorization of 'number'
			UpperCamelCase   :  Dict						     =     prime_factorization(__SCREAMING_SNAKE_CASE     )

			UpperCamelCase   :  List[Any]						     =     min(__SCREAMING_SNAKE_CASE     )

			# precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'ans' must been from type int"

			return ans
def 		UpperCamelCase     (       snake_case__	:   Optional[int]     )     ->					List[Any]:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'number' must been an int"
			assert isinstance(number % 2 == 0	,					__SCREAMING_SNAKE_CASE     ), "compare bust been from type bool"

			return number % 2 == 0
def 		UpperCamelCase     (       snake_case__	:   Dict     )     ->					Any:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ), "'number' must been an int"
			assert isinstance(number % 2 != 0	,					__SCREAMING_SNAKE_CASE     ), "compare bust been from type bool"

			return number % 2 != 0
def 		UpperCamelCase     (       snake_case__	:   int     )     ->					List[Any]:
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (number > 2) and is_even(__SCREAMING_SNAKE_CASE     )
			), "'number' must been an int, even and > 2"

			UpperCamelCase   :  Dict						     =     []  # this list will returned

			# creates a list of prime numbers between 2 up to 'number'
			UpperCamelCase   :  Union[str, Any]						     =     get_prime_numbers(__SCREAMING_SNAKE_CASE     )
			UpperCamelCase   :  Optional[Any]						     =     len(__SCREAMING_SNAKE_CASE     )

			# run variable for while-loops.
			UpperCamelCase   :  List[str]						     =     0
			UpperCamelCase   :  Any						     =     None

			# exit variable. for break up the loops
			UpperCamelCase   :  Tuple						     =     True

			while i < len_pn and loop:
						UpperCamelCase   :  str						     =     i + 1

						while j < len_pn and loop:
									if prime_numbers[i] + prime_numbers[j] == number:
												UpperCamelCase   :  Union[str, Any]						     =     False
												ans.append(prime_numbers[i]     )
												ans.append(prime_numbers[j]     )

									j += 1

						i += 1

			# precondition
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and (len(__SCREAMING_SNAKE_CASE     ) == 2)
			    and (ans[0] + ans[1] == number)
			    and is_prime(ans[0]     )
			    and is_prime(ans[1]     )
			), "'ans' must contains two primes. And sum of elements must been eq 'number'"

			return ans
def 		UpperCamelCase     (       snake_case__	:   Optional[int]	,					snake_case__	:   Dict     )     ->					Union[str, Any]:
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and (numbera >= 0)
			    and (numbera >= 0)
			), "'number1' and 'number2' must been positive integer."

			UpperCamelCase   :  Optional[int]						     =     0

			while numbera != 0:
						UpperCamelCase   :  int						     =     numbera % numbera
						UpperCamelCase   :  Tuple						     =     numbera
						UpperCamelCase   :  Union[str, Any]						     =     rest

			# precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (
			    numbera >= 0
			), "'number' must been from type int and positive"

			return numbera
def 		UpperCamelCase     (       snake_case__	:   Any	,					snake_case__	:   Any     )     ->					List[str]:
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and (numbera >= 1)
			    and (numbera >= 1)
			), "'number1' and 'number2' must been positive integer."

			UpperCamelCase   :  int						     =     1  # actual answer that will be return.

			# for kgV (x,1)
			if numbera > 1 and numbera > 1:
						# builds the prime factorization of 'number1' and 'number2'
						UpperCamelCase   :  Optional[int]						     =     prime_factorization(__SCREAMING_SNAKE_CASE     )
						UpperCamelCase   :  Union[str, Any]						     =     prime_factorization(__SCREAMING_SNAKE_CASE     )

			elif numbera == 1 or numbera == 1:
						UpperCamelCase   :  Tuple						     =     []
						UpperCamelCase   :  Optional[Any]						     =     []
						UpperCamelCase   :  Union[str, Any]						     =     max(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )

			UpperCamelCase   :  List[str]						     =     0
			UpperCamelCase   :  Optional[Any]						     =     0

			UpperCamelCase   :  Dict						     =     []  # captured numbers int both 'primeFac1' and 'primeFac2'

			# iterates through primeFac1
			for n in prime_fac_a:
						if n not in done:
									if n in prime_fac_a:
												UpperCamelCase   :  int						     =     prime_fac_a.count(__SCREAMING_SNAKE_CASE     )
												UpperCamelCase   :  int						     =     prime_fac_a.count(__SCREAMING_SNAKE_CASE     )

												for _ in range(max(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )     ):
															ans *= n

									else:
												UpperCamelCase   :  Optional[Any]						     =     prime_fac_a.count(__SCREAMING_SNAKE_CASE     )

												for _ in range(__SCREAMING_SNAKE_CASE     ):
															ans *= n

									done.append(__SCREAMING_SNAKE_CASE     )

    # iterates through primeFac2
			for n in prime_fac_a:
						if n not in done:
									UpperCamelCase   :  Tuple						     =     prime_fac_a.count(__SCREAMING_SNAKE_CASE     )

									for _ in range(__SCREAMING_SNAKE_CASE     ):
												ans *= n

									done.append(__SCREAMING_SNAKE_CASE     )

    # precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (
			    ans >= 0
			), "'ans' must been from type int and positive"

			return ans
def 		UpperCamelCase     (       snake_case__	:   int     )     ->					Any:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (n >= 0), "'number' must been a positive int"

			UpperCamelCase   :  Union[str, Any]						     =     0
			UpperCamelCase   :  Union[str, Any]						     =     2  # this variable holds the answer

			while index < n:
						index += 1

						ans += 1  # counts to the next number

						# if ans not prime then
						# runs to the next prime number.
						while not is_prime(__SCREAMING_SNAKE_CASE     ):
									ans += 1

    # precondition
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and is_prime(
			    __SCREAMING_SNAKE_CASE     ), "'ans' must been a prime number and from type int"

			return ans
def 		UpperCamelCase     (       snake_case__	:   Optional[int]	,					snake_case__	:   str     )     ->					Union[str, Any]:
			assert (
			    is_prime(__SCREAMING_SNAKE_CASE     ) and is_prime(__SCREAMING_SNAKE_CASE     ) and (p_number_a < p_number_a)
			), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

			UpperCamelCase   :  Tuple						     =     p_number_a + 1  # jump to the next number

			UpperCamelCase   :  int						     =     []  # this list will be returns.

			# if number is not prime then
			# fetch the next prime number.
			while not is_prime(__SCREAMING_SNAKE_CASE     ):
						number += 1

			while number < p_number_a:
						ans.append(__SCREAMING_SNAKE_CASE     )

						number += 1

						# fetch the next prime number.
						while not is_prime(__SCREAMING_SNAKE_CASE     ):
									number += 1

    # precondition
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and ans[0] != p_number_a
			    and ans[len(__SCREAMING_SNAKE_CASE     ) - 1] != p_number_a
			), "'ans' must been a list without the arguments"

			# 'ans' contains not 'pNumber1' and 'pNumber2' !
			return ans
def 		UpperCamelCase     (       snake_case__	:   Dict     )     ->					List[Any]:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (n >= 1), "'n' must been int and >= 1"

			UpperCamelCase   :  Dict						     =     []  # will be returned.

			for divisor in range(1	,					n + 1     ):
						if n % divisor == 0:
									ans.append(__SCREAMING_SNAKE_CASE     )

    # precondition
			assert ans[0] == 1 and ans[len(__SCREAMING_SNAKE_CASE     ) - 1] == n, "Error in function getDivisiors(...)"

			return ans
def 		UpperCamelCase     (       snake_case__	:   Optional[int]     )     ->					Union[str, Any]:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (
			    number > 1
			), "'number' must been an int and >= 1"

			UpperCamelCase   :  List[str]						     =     get_divisors(__SCREAMING_SNAKE_CASE     )

			# precondition
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and (divisors[0] == 1)
			    and (divisors[len(__SCREAMING_SNAKE_CASE     ) - 1] == number)
			), "Error in help-function getDivisiors(...)"

			# summed all divisors up to 'number' (exclusive), hence [:-1]
			return sum(divisors[:-1]     ) == number
def 		UpperCamelCase     (       snake_case__	:   Union[str, Any]	,					snake_case__	:   Optional[int]     )     ->					List[Any]:
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and (denominator != 0)
			), "The arguments must been from type int and 'denominator' != 0"

			# build the greatest common divisor of numerator and denominator.
			UpperCamelCase   :  Dict						     =     gcd(abs(__SCREAMING_SNAKE_CASE     )	,					abs(__SCREAMING_SNAKE_CASE     )     )

			# precondition
			assert (
			    isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     )
			    and (numerator % gcd_of_fraction == 0)
			    and (denominator % gcd_of_fraction == 0)
			), "Error in function gcd(...,...)"

			return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)
def 		UpperCamelCase     (       snake_case__	:   List[str]     )     ->					Tuple:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (n >= 0), "'n' must been a int and >= 0"

			UpperCamelCase   :  Union[str, Any]						     =     1  # this will be return.

			for factor in range(1	,					n + 1     ):
						ans *= factor

			return ans


def 		UpperCamelCase     (       snake_case__	:   Optional[int]     )     ->					Any:
			assert isinstance(__SCREAMING_SNAKE_CASE	,					__SCREAMING_SNAKE_CASE     ) and (n >= 0), "'n' must been an int and >= 0"

			UpperCamelCase   :  int						     =     0
			UpperCamelCase   :  int						     =     1
			UpperCamelCase   :  List[Any]						     =     1  # this will be return

			for _ in range(n - 1     ):
						UpperCamelCase   :  List[str]						     =     ans
						ans += fiba
						UpperCamelCase   :  Any						     =     tmp

			return ans








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     lowerCAmelCase_		(  unittest.TestCase							):
       def  snake_case_	(      self,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)					->		Union[str, Any]:
          UpperCamelCase   :  List[str]						     =     jnp.ones((batch_size, length)	) / length
          return scores
       def  snake_case_	(      self	)					->		Optional[Any]:
          UpperCamelCase   :  Optional[Any]						     =     None
          UpperCamelCase   :  Optional[int]						     =     20

          UpperCamelCase   :  Optional[Any]						     =     self._get_uniform_logits(batch_size=2,      length=SCREAMING_SNAKE_CASE_	)

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

          # compute softmax
          UpperCamelCase   :  List[str]						     =     jax.nn.softmax(SCREAMING_SNAKE_CASE_,      axis=-1	)

          UpperCamelCase   :  List[Any]						     =     FlaxTemperatureLogitsWarper(temperature=0.5	)
          UpperCamelCase   :  int						     =     FlaxTemperatureLogitsWarper(temperature=1.3	)

          UpperCamelCase   :  Tuple						     =     jax.nn.softmax(temp_dist_warper_sharper(SCREAMING_SNAKE_CASE_,      scores.copy(),      cur_len=SCREAMING_SNAKE_CASE_	),      axis=-1	)
          UpperCamelCase   :  Any						     =     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  snake_case_	(      self	)					->		Optional[Any]:
          UpperCamelCase   :  Dict						     =     None
          UpperCamelCase   :  Any						     =     10
          UpperCamelCase   :  Any						     =     2

          # create ramp distribution
          UpperCamelCase   :  List[Any]						     =     np.broadcast_to(np.arange(SCREAMING_SNAKE_CASE_	)[None, :],      (batch_size, vocab_size)	).copy()
          UpperCamelCase   :  Tuple						     =     ramp_logits[1:, : vocab_size // 2] + vocab_size

          UpperCamelCase   :  Dict						     =     FlaxTopKLogitsWarper(3	)

          UpperCamelCase   :  Tuple						     =     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
          UpperCamelCase   :  Optional[int]						     =     5
          UpperCamelCase   :  Optional[int]						     =     FlaxTopKLogitsWarper(top_k=1,      filter_value=0.0,      min_tokens_to_keep=3	)

          UpperCamelCase   :  Union[str, Any]						     =     np.broadcast_to(np.arange(SCREAMING_SNAKE_CASE_	)[None, :],      (batch_size, length)	).copy()
          UpperCamelCase   :  List[str]						     =     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  snake_case_	(      self	)					->		Union[str, Any]:
          UpperCamelCase   :  int						     =     None
          UpperCamelCase   :  List[str]						     =     10
          UpperCamelCase   :  Optional[Any]						     =     2

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

          UpperCamelCase   :  Optional[Any]						     =     FlaxTopPLogitsWarper(0.8	)
          UpperCamelCase   :  int						     =     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
          UpperCamelCase   :  Any						     =     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
          UpperCamelCase   :  Optional[Any]						     =     np.broadcast_to(np.arange(SCREAMING_SNAKE_CASE_	)[None, :],      (batch_size, vocab_size)	).copy() - (
              vocab_size // 2
          )

          # make ramp_logits more extreme
          UpperCamelCase   :  Tuple						     =     ramp_logits[1] * 1_00.0

          # make sure at least 2 tokens are kept
          UpperCamelCase   :  int						     =     FlaxTopPLogitsWarper(0.9,      min_tokens_to_keep=2,      filter_value=0.0	)
          UpperCamelCase   :  List[str]						     =     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  snake_case_	(      self	)					->		List[Any]:
          UpperCamelCase   :  Union[str, Any]						     =     20
          UpperCamelCase   :  Union[str, Any]						     =     4
          UpperCamelCase   :  Optional[int]						     =     0

          UpperCamelCase   :  Dict						     =     FlaxMinLengthLogitsProcessor(min_length=10,      eos_token_id=SCREAMING_SNAKE_CASE_	)

          # check that min length is applied at length 5
          UpperCamelCase   :  List[str]						     =     ids_tensor((batch_size, 20),      vocab_size=20	)
          UpperCamelCase   :  Any						     =     5
          UpperCamelCase   :  Tuple						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Tuple						     =     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
          UpperCamelCase   :  Any						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Union[str, Any]						     =     15
          UpperCamelCase   :  str						     =     min_dist_processor(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          self.assertFalse(jnp.isinf(SCREAMING_SNAKE_CASE_	).any()	)
       def  snake_case_	(      self	)					->		Dict:
          UpperCamelCase   :  str						     =     20
          UpperCamelCase   :  List[Any]						     =     4
          UpperCamelCase   :  List[str]						     =     0

          UpperCamelCase   :  int						     =     FlaxForcedBOSTokenLogitsProcessor(bos_token_id=SCREAMING_SNAKE_CASE_	)

          # check that all scores are -inf except the bos_token_id score
          UpperCamelCase   :  Any						     =     ids_tensor((batch_size, 1),      vocab_size=20	)
          UpperCamelCase   :  List[Any]						     =     1
          UpperCamelCase   :  Tuple						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Optional[Any]						     =     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
          UpperCamelCase   :  Dict						     =     3
          UpperCamelCase   :  str						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  int						     =     logits_processor(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          self.assertFalse(jnp.isinf(SCREAMING_SNAKE_CASE_	).any()	)
       def  snake_case_	(      self	)					->		List[str]:
          UpperCamelCase   :  Union[str, Any]						     =     20
          UpperCamelCase   :  Optional[Any]						     =     4
          UpperCamelCase   :  List[Any]						     =     0
          UpperCamelCase   :  int						     =     5

          UpperCamelCase   :  Tuple						     =     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
          UpperCamelCase   :  str						     =     ids_tensor((batch_size, 4),      vocab_size=20	)
          UpperCamelCase   :  Tuple						     =     4
          UpperCamelCase   :  Union[str, Any]						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     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
          UpperCamelCase   :  str						     =     3
          UpperCamelCase   :  List[Any]						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Union[str, Any]						     =     logits_processor(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          self.assertFalse(jnp.isinf(SCREAMING_SNAKE_CASE_	).any()	)
       def  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  int						     =     4
          UpperCamelCase   :  Tuple						     =     10
          UpperCamelCase   :  str						     =     15
          UpperCamelCase   :  List[str]						     =     2
          UpperCamelCase   :  Any						     =     1
          UpperCamelCase   :  List[str]						     =     15

          # dummy input_ids and scores
          UpperCamelCase   :  Dict						     =     ids_tensor((batch_size, sequence_length),      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     input_ids.copy()

          UpperCamelCase   :  Any						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     scores.copy()

          # instantiate all dist processors
          UpperCamelCase   :  List[str]						     =     FlaxTemperatureLogitsWarper(temperature=0.5	)
          UpperCamelCase   :  Optional[Any]						     =     FlaxTopKLogitsWarper(3	)
          UpperCamelCase   :  Optional[int]						     =     FlaxTopPLogitsWarper(0.8	)

          # instantiate all logits processors
          UpperCamelCase   :  Optional[Any]						     =     FlaxMinLengthLogitsProcessor(min_length=10,      eos_token_id=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Dict						     =     FlaxForcedBOSTokenLogitsProcessor(bos_token_id=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[Any]						     =     FlaxForcedEOSTokenLogitsProcessor(max_length=SCREAMING_SNAKE_CASE_,      eos_token_id=SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  List[str]						     =     10

          # no processor list
          UpperCamelCase   :  Any						     =     temp_dist_warp(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Dict						     =     top_k_warp(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Dict						     =     top_p_warp(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Dict						     =     min_dist_proc(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Union[str, Any]						     =     bos_dist_proc(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[str]						     =     eos_dist_proc(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)

          # with processor list
          UpperCamelCase   :  List[str]						     =     FlaxLogitsProcessorList(
              [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]	)
          UpperCamelCase   :  Optional[Any]						     =     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  snake_case_	(      self	)					->		int:
          UpperCamelCase   :  Optional[Any]						     =     4
          UpperCamelCase   :  Tuple						     =     10
          UpperCamelCase   :  Union[str, Any]						     =     15
          UpperCamelCase   :  Union[str, Any]						     =     2
          UpperCamelCase   :  Optional[Any]						     =     1
          UpperCamelCase   :  int						     =     15

          # dummy input_ids and scores
          UpperCamelCase   :  Dict						     =     ids_tensor((batch_size, sequence_length),      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  str						     =     input_ids.copy()

          UpperCamelCase   :  Optional[int]						     =     self._get_uniform_logits(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Union[str, Any]						     =     scores.copy()

          # instantiate all dist processors
          UpperCamelCase   :  Dict						     =     FlaxTemperatureLogitsWarper(temperature=0.5	)
          UpperCamelCase   :  Optional[Any]						     =     FlaxTopKLogitsWarper(3	)
          UpperCamelCase   :  Union[str, Any]						     =     FlaxTopPLogitsWarper(0.8	)

          # instantiate all logits processors
          UpperCamelCase   :  str						     =     FlaxMinLengthLogitsProcessor(min_length=10,      eos_token_id=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Any						     =     FlaxForcedBOSTokenLogitsProcessor(bos_token_id=SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  Optional[int]						     =     FlaxForcedEOSTokenLogitsProcessor(max_length=SCREAMING_SNAKE_CASE_,      eos_token_id=SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  Any						     =     10

          # no processor list
          def run_no_processor_list(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	):
             UpperCamelCase   :  Optional[Any]						     =     temp_dist_warp(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  str						     =     top_k_warp(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  Any						     =     top_p_warp(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  List[str]						     =     min_dist_proc(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  List[str]						     =     bos_dist_proc(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
             UpperCamelCase   :  List[str]						     =     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_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	):
             UpperCamelCase   :  Tuple						     =     FlaxLogitsProcessorList(
                 [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]	)
             UpperCamelCase   :  Union[str, Any]						     =     processor(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      cur_len=SCREAMING_SNAKE_CASE_	)
             return scores

          UpperCamelCase   :  Dict						     =     jax.jit(SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  List[str]						     =     jax.jit(SCREAMING_SNAKE_CASE_	)

          UpperCamelCase   :  int						     =     jitted_run_no_processor_list(SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_,      SCREAMING_SNAKE_CASE_	)
          UpperCamelCase   :  int						     =     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()	)



