

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 				UpperCAmelCase_		(			unittest.TestCase   ):
							"""simple docstring"""







							def 				__lowercase				(			self       ,							_a       ,							_a       )    ->    Optional[int]:
												_a	:    str         =		jnp.ones((batch_size, length)       ) / length
												return scores


							def 				__lowercase				(			self       )    ->    str:
												_a	:    Optional[int]         =		None
												_a	:    int         =		2_0

												_a	:    int         =		self._get_uniform_logits(batch_size=2       ,							length=_a       )

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

												# compute softmax
												_a	:    List[Any]         =		jax.nn.softmax(_a       ,							axis=-1       )

												_a	:    Any         =		FlaxTemperatureLogitsWarper(temperature=0.5       )
												_a	:    Optional[int]         =		FlaxTemperatureLogitsWarper(temperature=1.3       )

												_a	:    int         =		jax.nn.softmax(temp_dist_warper_sharper(_a       ,							scores.copy()       ,							cur_len=_a       )       ,							axis=-1       )
												_a	:    Union[str, Any]         =		jax.nn.softmax(temp_dist_warper_smoother(_a       ,							scores.copy()       ,							cur_len=_a       )       ,							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 				__lowercase				(			self       )    ->    Optional[int]:
												_a	:    str         =		None
												_a	:    Union[str, Any]         =		1_0
												_a	:    str         =		2

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

												_a	:    Optional[Any]         =		FlaxTopKLogitsWarper(3       )

												_a	:    Union[str, Any]         =		top_k_warp(_a       ,							_a       ,							cur_len=_a       )

												# 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	:    Optional[int]         =		5
												_a	:    Union[str, Any]         =		FlaxTopKLogitsWarper(top_k=1       ,							filter_value=0.0       ,							min_tokens_to_keep=3       )

												_a	:    Dict         =		np.broadcast_to(np.arange(_a       )[None, :]       ,							(batch_size, length)       ).copy()
												_a	:    int         =		top_k_warp_safety_check(_a       ,							_a       ,							cur_len=_a       )

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


							def 				__lowercase				(			self       )    ->    Union[str, Any]:
												_a	:    List[Any]         =		None
												_a	:    Tuple         =		1_0
												_a	:    int         =		2

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

												_a	:    List[str]         =		FlaxTopPLogitsWarper(0.8       )
												_a	:    Optional[Any]         =		np.exp(top_p_warp(_a       ,							_a       ,							cur_len=_a       )       )

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

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

												# make ramp_logits more extreme
												_a	:    Optional[Any]         =		ramp_logits[1] * 100.0

												# make sure at least 2 tokens are kept
												_a	:    List[Any]         =		FlaxTopPLogitsWarper(0.9       ,							min_tokens_to_keep=2       ,							filter_value=0.0       )
												_a	:    int         =		top_p_warp(_a       ,							_a       ,							cur_len=_a       )

												# 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 				__lowercase				(			self       )    ->    List[Any]:
												_a	:    Tuple         =		2_0
												_a	:    int         =		4
												_a	:    List[Any]         =		0

												_a	:    Any         =		FlaxMinLengthLogitsProcessor(min_length=1_0       ,							eos_token_id=_a       )

												# check that min length is applied at length 5
												_a	:    Tuple         =		ids_tensor((batch_size, 2_0)       ,							vocab_size=2_0       )
												_a	:    Optional[int]         =		5
												_a	:    Any         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    Union[str, Any]         =		min_dist_processor(_a       ,							_a       ,							cur_len=_a       )
												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	:    int         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    Dict         =		1_5
												_a	:    Union[str, Any]         =		min_dist_processor(_a       ,							_a       ,							cur_len=_a       )
												self.assertFalse(jnp.isinf(_a       ).any()       )


							def 				__lowercase				(			self       )    ->    Optional[Any]:
												_a	:    List[str]         =		2_0
												_a	:    str         =		4
												_a	:    Optional[Any]         =		0

												_a	:    Optional[int]         =		FlaxForcedBOSTokenLogitsProcessor(bos_token_id=_a       )

												# check that all scores are -inf except the bos_token_id score
												_a	:    Optional[Any]         =		ids_tensor((batch_size, 1)       ,							vocab_size=2_0       )
												_a	:    List[str]         =		1
												_a	:    Tuple         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    Dict         =		logits_processor(_a       ,							_a       ,							cur_len=_a       )
												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	:    Optional[Any]         =		3
												_a	:    str         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    int         =		logits_processor(_a       ,							_a       ,							cur_len=_a       )
												self.assertFalse(jnp.isinf(_a       ).any()       )


							def 				__lowercase				(			self       )    ->    Dict:
												_a	:    Optional[int]         =		2_0
												_a	:    Any         =		4
												_a	:    Union[str, Any]         =		0
												_a	:    Union[str, Any]         =		5

												_a	:    str         =		FlaxForcedEOSTokenLogitsProcessor(max_length=_a       ,							eos_token_id=_a       )

												# check that all scores are -inf except the eos_token_id when max_length is reached
												_a	:    Optional[Any]         =		ids_tensor((batch_size, 4)       ,							vocab_size=2_0       )
												_a	:    Union[str, Any]         =		4
												_a	:    Dict         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    str         =		logits_processor(_a       ,							_a       ,							cur_len=_a       )
												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	:    Tuple         =		3
												_a	:    List[Any]         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    List[str]         =		logits_processor(_a       ,							_a       ,							cur_len=_a       )
												self.assertFalse(jnp.isinf(_a       ).any()       )


							def 				__lowercase				(			self       )    ->    int:
												_a	:    Any         =		4
												_a	:    str         =		1_0
												_a	:    List[str]         =		1_5
												_a	:    Optional[int]         =		2
												_a	:    str         =		1
												_a	:    int         =		1_5

												# dummy input_ids and scores
												_a	:    Optional[int]         =		ids_tensor((batch_size, sequence_length)       ,							_a       )
												_a	:    List[Any]         =		input_ids.copy()

												_a	:    str         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    Tuple         =		scores.copy()

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

												# instantiate all logits processors
												_a	:    Tuple         =		FlaxMinLengthLogitsProcessor(min_length=1_0       ,							eos_token_id=_a       )
												_a	:    Dict         =		FlaxForcedBOSTokenLogitsProcessor(bos_token_id=_a       )
												_a	:    Optional[int]         =		FlaxForcedEOSTokenLogitsProcessor(max_length=_a       ,							eos_token_id=_a       )

												_a	:    Optional[int]         =		1_0

												# no processor list
												_a	:    Tuple         =		temp_dist_warp(_a       ,							_a       ,							cur_len=_a       )
												_a	:    List[str]         =		top_k_warp(_a       ,							_a       ,							cur_len=_a       )
												_a	:    Tuple         =		top_p_warp(_a       ,							_a       ,							cur_len=_a       )
												_a	:    Dict         =		min_dist_proc(_a       ,							_a       ,							cur_len=_a       )
												_a	:    str         =		bos_dist_proc(_a       ,							_a       ,							cur_len=_a       )
												_a	:    int         =		eos_dist_proc(_a       ,							_a       ,							cur_len=_a       )

												# with processor list
												_a	:    Optional[int]         =		FlaxLogitsProcessorList(
												    [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]       )
												_a	:    List[Any]         =		processor(_a       ,							_a       ,							cur_len=_a       )

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

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




							def 				__lowercase				(			self       )    ->    Dict:
												_a	:    str         =		4
												_a	:    Optional[Any]         =		1_0
												_a	:    Tuple         =		1_5
												_a	:    Optional[int]         =		2
												_a	:    Optional[Any]         =		1
												_a	:    List[Any]         =		1_5

												# dummy input_ids and scores
												_a	:    int         =		ids_tensor((batch_size, sequence_length)       ,							_a       )
												_a	:    Union[str, Any]         =		input_ids.copy()

												_a	:    Any         =		self._get_uniform_logits(_a       ,							_a       )
												_a	:    Dict         =		scores.copy()

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

												# instantiate all logits processors
												_a	:    List[str]         =		FlaxMinLengthLogitsProcessor(min_length=1_0       ,							eos_token_id=_a       )
												_a	:    Optional[Any]         =		FlaxForcedBOSTokenLogitsProcessor(bos_token_id=_a       )
												_a	:    Optional[int]         =		FlaxForcedEOSTokenLogitsProcessor(max_length=_a       ,							eos_token_id=_a       )

												_a	:    List[Any]         =		1_0

												# no processor list
												def run_no_processor_list(_a       ,							_a       ,							_a       ):
																	_a	:    int         =		temp_dist_warp(_a       ,							_a       ,							cur_len=_a       )
																	_a	:    List[str]         =		top_k_warp(_a       ,							_a       ,							cur_len=_a       )
																	_a	:    int         =		top_p_warp(_a       ,							_a       ,							cur_len=_a       )
																	_a	:    List[Any]         =		min_dist_proc(_a       ,							_a       ,							cur_len=_a       )
																	_a	:    List[str]         =		bos_dist_proc(_a       ,							_a       ,							cur_len=_a       )
																	_a	:    Tuple         =		eos_dist_proc(_a       ,							_a       ,							cur_len=_a       )
																	return scores

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

												_a	:    int         =		jax.jit(_a       )
												_a	:    Dict         =		jax.jit(_a       )

												_a	:    int         =		jitted_run_no_processor_list(_a       ,							_a       ,							_a       )
												_a	:    int         =		jitted_run_processor_list(_a       ,							_a       ,							_a       )

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

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






import requests

a__				=		'''YOUR API KEY'''



def    __UpperCAmelCase (	__a      :			str		,__a      :			str = giphy_api_key	)			->     list:

					"""simple docstring"""

					_a	:    Optional[Any]         =		'''+'''.join(query.split()	)
					_a	:    Union[str, Any]         =		F"""https://api.giphy.com/v1/gifs/search?q={formatted_query}&api_key={api_key}"""
					_a	:    List[Any]         =		requests.get(__a	).json()['''data''']
					return [gif["url"] for gif in gifs]


if __name__ == "__main__":
			print('''\n'''.join(get_gifs('''space ship''')))



