



'''simple docstring'''
import json
import os
from typing import Optional

import numpy as np

from ...feature_extraction_utils import BatchFeature
from ...processing_utils import ProcessorMixin
from ...utils import logging
from ...utils.hub import get_file_from_repo
from ..auto import AutoTokenizer


snake_case_ :	List[Any]         =  logging.get_logger(__name__)






class 							lowercase__	(							lowercase   ):
	lowercase__  				=			"""AutoTokenizer"""
	lowercase__  				=			["""tokenizer"""]

	lowercase__  				=			{
	    """semantic_prompt""": 1,
	    """coarse_prompt""": 2,
	    """fine_prompt""": 2,
	}





	def __init__( self					:				List[str] ,lowerCamelCase__					:				Tuple ,lowerCamelCase__					:				Tuple=None ):







							'''simple docstring'''
							super().__init__(lowerCamelCase__ )

							_UpperCamelCase					:		Dict 				=   speaker_embeddings





	@classmethod
	def 	UpperCamelCase_  ( cls					:				Union[str, Any] ,lowerCamelCase__					:				int ,lowerCamelCase__					:				str="speaker_embeddings_path.json" ,**lowerCamelCase__					:				Optional[Any] ):







							'''simple docstring'''

							if speaker_embeddings_dict_path is not None:
													_UpperCamelCase					:		Optional[Any] 				=   get_file_from_repo(
													    lowerCamelCase__ ,lowerCamelCase__ ,subfolder=kwargs.pop('subfolder' ,lowerCamelCase__ ) ,cache_dir=kwargs.pop('cache_dir' ,lowerCamelCase__ ) ,force_download=kwargs.pop('force_download' ,lowerCamelCase__ ) ,proxies=kwargs.pop('proxies' ,lowerCamelCase__ ) ,resume_download=kwargs.pop('resume_download' ,lowerCamelCase__ ) ,local_files_only=kwargs.pop('local_files_only' ,lowerCamelCase__ ) ,use_auth_token=kwargs.pop('use_auth_token' ,lowerCamelCase__ ) ,revision=kwargs.pop('revision' ,lowerCamelCase__ ) ,)
													if speaker_embeddings_path is None:
																			logger.warning(
																			    F'`{os.path.join(lowerCamelCase__ ,lowerCamelCase__ )}` does not exists\n                    , no preloaded speaker embeddings will be used - Make sure to provide a correct path to the json\n                    dictionnary if wanted, otherwise set `speaker_embeddings_dict_path=None`.' )
																			_UpperCamelCase					:		Union[str, Any] 				=   None
													else:
																			with open(lowerCamelCase__ ) as speaker_embeddings_json:
																									_UpperCamelCase					:		Optional[int] 				=   json.load(lowerCamelCase__ )
							else:
													_UpperCamelCase					:		Tuple 				=   None

							_UpperCamelCase					:		Tuple 				=   AutoTokenizer.from_pretrained(lowerCamelCase__ ,**lowerCamelCase__ )

							return cls(tokenizer=lowerCamelCase__ ,speaker_embeddings=lowerCamelCase__ )





	def 	UpperCamelCase_  ( self					:				Tuple ,lowerCamelCase__					:				Union[str, Any] ,lowerCamelCase__					:				int="speaker_embeddings_path.json" ,lowerCamelCase__					:				Dict="speaker_embeddings" ,lowerCamelCase__					:				bool = False ,**lowerCamelCase__					:				Tuple ,):







							'''simple docstring'''
							if self.speaker_embeddings is not None:
													os.makedirs(os.path.join(lowerCamelCase__ ,lowerCamelCase__ ,'v2' ) ,exist_ok=lowerCamelCase__ )

													_UpperCamelCase					:		Tuple 				=   {}

													_UpperCamelCase					:		Optional[Any] 				=   save_directory

													for prompt_key in self.speaker_embeddings:
																			if prompt_key != "repo_or_path":
																									_UpperCamelCase					:		Any 				=   self._load_voice_preset(lowerCamelCase__ )

																									_UpperCamelCase					:		Union[str, Any] 				=   {}
																									for key in self.speaker_embeddings[prompt_key]:
																															np.save(
																															    os.path.join(
																															        embeddings_dict['repo_or_path'] ,lowerCamelCase__ ,F'{prompt_key}_{key}' ) ,voice_preset[key] ,allow_pickle=lowerCamelCase__ ,)
																															_UpperCamelCase					:		List[str] 				=   os.path.join(lowerCamelCase__ ,F'{prompt_key}_{key}.npy' )

																									_UpperCamelCase					:		str 				=   tmp_dict

													with open(os.path.join(lowerCamelCase__ ,lowerCamelCase__ ) ,'w' ) as fp:
																			json.dump(lowerCamelCase__ ,lowerCamelCase__ )

							super().save_pretrained(lowerCamelCase__ ,lowerCamelCase__ ,**lowerCamelCase__ )





	def 	UpperCamelCase_  ( self					:				Union[str, Any] ,lowerCamelCase__					:				str = None ,**lowerCamelCase__					:				Dict ):







							'''simple docstring'''
							_UpperCamelCase					:		Tuple 				=   self.speaker_embeddings[voice_preset]

							_UpperCamelCase					:		Union[str, Any] 				=   {}
							for key in ["semantic_prompt", "coarse_prompt", "fine_prompt"]:
													if key not in voice_preset_paths:
																			raise ValueError(
																			    F'Voice preset unrecognized, missing {key} as a key in self.speaker_embeddings[{voice_preset}].' )

													_UpperCamelCase					:		Dict 				=   get_file_from_repo(
													    self.speaker_embeddings.get('repo_or_path' ,'/' ) ,voice_preset_paths[key] ,subfolder=kwargs.pop('subfolder' ,lowerCamelCase__ ) ,cache_dir=kwargs.pop('cache_dir' ,lowerCamelCase__ ) ,force_download=kwargs.pop('force_download' ,lowerCamelCase__ ) ,proxies=kwargs.pop('proxies' ,lowerCamelCase__ ) ,resume_download=kwargs.pop('resume_download' ,lowerCamelCase__ ) ,local_files_only=kwargs.pop('local_files_only' ,lowerCamelCase__ ) ,use_auth_token=kwargs.pop('use_auth_token' ,lowerCamelCase__ ) ,revision=kwargs.pop('revision' ,lowerCamelCase__ ) ,)
													if path is None:
																			raise ValueError(
																			    F'`{os.path.join(self.speaker_embeddings.get("repo_or_path" ,"/" ) ,voice_preset_paths[key] )}` does not exists\n                    , no preloaded voice preset will be used - Make sure to provide correct paths to the {voice_preset}\n                    embeddings.' )

													_UpperCamelCase					:		List[str] 				=   np.load(lowerCamelCase__ )

							return voice_preset_dict





	def 	UpperCamelCase_  ( self					:				Any ,lowerCamelCase__					:				Optional[dict] = None ):







							'''simple docstring'''
							for key in ["semantic_prompt", "coarse_prompt", "fine_prompt"]:
													if key not in voice_preset:
																			raise ValueError(F'Voice preset unrecognized, missing {key} as a key.' )

													if not isinstance(voice_preset[key] ,np.ndarray ):
																			raise ValueError(F'{key} voice preset must be a {str(self.preset_shape[key] )}D ndarray.' )

													if len(voice_preset[key].shape ) != self.preset_shape[key]:
																			raise ValueError(F'{key} voice preset must be a {str(self.preset_shape[key] )}D ndarray.' )





	def __call__( self					:				Any ,lowerCamelCase__					:				Optional[Any]=None ,lowerCamelCase__					:				Union[str, Any]=None ,lowerCamelCase__					:				Any="pt" ,lowerCamelCase__					:				Dict=256 ,lowerCamelCase__					:				int=False ,lowerCamelCase__					:				int=True ,lowerCamelCase__					:				List[str]=False ,**lowerCamelCase__					:				Union[str, Any] ,):







							'''simple docstring'''
							if voice_preset is not None and not isinstance(lowerCamelCase__ ,lowerCamelCase__ ):
													if (
													    isinstance(lowerCamelCase__ ,lowerCamelCase__ )
													    and self.speaker_embeddings is not None
													    and voice_preset in self.speaker_embeddings
													):
																			_UpperCamelCase					:		Optional[int] 				=   self._load_voice_preset(lowerCamelCase__ )

													else:
																			if isinstance(lowerCamelCase__ ,lowerCamelCase__ ) and not voice_preset.endswith('.npz' ):
																									_UpperCamelCase					:		Tuple 				=   voice_preset + '.npz'

																			_UpperCamelCase					:		str 				=   np.load(lowerCamelCase__ )

							if voice_preset is not None:
													self._validate_voice_preset_dict(lowerCamelCase__ ,**lowerCamelCase__ )
													_UpperCamelCase					:		Union[str, Any] 				=   BatchFeature(data=lowerCamelCase__ ,tensor_type=lowerCamelCase__ )

							_UpperCamelCase					:		Union[str, Any] 				=   self.tokenizer(
							    lowerCamelCase__ ,return_tensors=lowerCamelCase__ ,padding='max_length' ,max_length=lowerCamelCase__ ,return_attention_mask=lowerCamelCase__ ,return_token_type_ids=lowerCamelCase__ ,add_special_tokens=lowerCamelCase__ ,**lowerCamelCase__ ,)

							if voice_preset is not None:
													_UpperCamelCase					:		Optional[Any] 				=   voice_preset

							return encoded_text






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			):




       """simple docstring"""



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->List[Any]:




         '''simple docstring'''





         A_      :				Optional[int]		     =					jnp.ones((batch_size, length)		) / length
         return scores



       def        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					None
         A_      :				Any		     =					20

         A_      :				Any		     =					self._get_uniform_logits(batch_size=2				,       length=_SCREAMING_SNAKE_CASE		)

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

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

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

         A_      :				Optional[Any]		     =					jax.nn.softmax(temp_dist_warper_sharper(_SCREAMING_SNAKE_CASE				,       scores.copy()				,       cur_len=_SCREAMING_SNAKE_CASE		)				,       axis=-1		)
         A_      :				List[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		)->List[Any]:




         '''simple docstring'''





         A_      :				Any		     =					None
         A_      :				List[Any]		     =					10
         A_      :				str		     =					2

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

         A_      :				Any		     =					FlaxTopKLogitsWarper(3		)

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

         A_      :				Optional[Any]		     =					np.broadcast_to(np.arange(_SCREAMING_SNAKE_CASE		)[None, :]				,       (batch_size, length)		).copy()
         A_      :				Dict		     =					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		)->Any:




         '''simple docstring'''





         A_      :				str		     =					None
         A_      :				Optional[Any]		     =					10
         A_      :				Any		     =					2

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

         A_      :				str		     =					FlaxTopPLogitsWarper(0.8		)
         A_      :				Optional[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
         A_      :				Tuple		     =					np.array([[0.3, 0.0, 0.0, 0.5], [0.0, 0.3, 0.3, 0.2_5]]		)
         self.assertTrue(np.allclose(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       atol=1e-3		)		)

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

         # make ramp_logits more extreme
         A_      :				str		     =					ramp_logits[1] * 1_0_0.0

         # make sure at least 2 tokens are kept
         A_      :				str		     =					FlaxTopPLogitsWarper(0.9				,       min_tokens_to_keep=2				,       filter_value=0.0		)
         A_      :				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		)->Any:




         '''simple docstring'''





         A_      :				str		     =					20
         A_      :				Union[str, Any]		     =					4
         A_      :				Optional[Any]		     =					0

         A_      :				Union[str, Any]		     =					FlaxMinLengthLogitsProcessor(min_length=10				,       eos_token_id=_SCREAMING_SNAKE_CASE		)

         # check that min length is applied at length 5
         A_      :				int		     =					ids_tensor((batch_size, 20)				,       vocab_size=20		)
         A_      :				List[Any]		     =					5
         A_      :				Optional[int]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Optional[int]		     =					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_      :				Tuple		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Any		     =					15
         A_      :				int		     =					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		)->Optional[Any]:




         '''simple docstring'''





         A_      :				Optional[int]		     =					20
         A_      :				Optional[int]		     =					4
         A_      :				Optional[int]		     =					0

         A_      :				Optional[Any]		     =					FlaxForcedBOSTokenLogitsProcessor(bos_token_id=_SCREAMING_SNAKE_CASE		)

         # check that all scores are -inf except the bos_token_id score
         A_      :				Optional[Any]		     =					ids_tensor((batch_size, 1)				,       vocab_size=20		)
         A_      :				str		     =					1
         A_      :				List[str]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[str]		     =					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_      :				Optional[int]		     =					3
         A_      :				List[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Tuple		     =					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]:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					20
         A_      :				str		     =					4
         A_      :				Dict		     =					0
         A_      :				Optional[int]		     =					5

         A_      :				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
         A_      :				List[Any]		     =					ids_tensor((batch_size, 4)				,       vocab_size=20		)
         A_      :				Any		     =					4
         A_      :				Optional[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[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
         A_      :				int		     =					3
         A_      :				Union[str, Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Dict		     =					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		)->str:




         '''simple docstring'''





         A_      :				str		     =					4
         A_      :				Dict		     =					10
         A_      :				Union[str, Any]		     =					15
         A_      :				str		     =					2
         A_      :				int		     =					1
         A_      :				List[str]		     =					15

         # dummy input_ids and scores
         A_      :				Tuple		     =					ids_tensor((batch_size, sequence_length)				,       _SCREAMING_SNAKE_CASE		)
         A_      :				int		     =					input_ids.copy()

         A_      :				List[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Union[str, Any]		     =					scores.copy()

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

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

         A_      :				Union[str, Any]		     =					10

         # no processor list
         A_      :				int		     =					temp_dist_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				List[str]		     =					top_k_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Any		     =					top_p_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Dict		     =					min_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[int]		     =					bos_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
         A_      :				Optional[Any]		     =					eos_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)

         # with processor list
         A_      :				Any		     =					FlaxLogitsProcessorList(
             [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]		)
         A_      :				List[str]		     =					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		)->Dict:




         '''simple docstring'''





         A_      :				str		     =					4
         A_      :				Dict		     =					10
         A_      :				Tuple		     =					15
         A_      :				List[str]		     =					2
         A_      :				List[str]		     =					1
         A_      :				Union[str, Any]		     =					15

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

         A_      :				Optional[Any]		     =					self._get_uniform_logits(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				Tuple		     =					scores.copy()

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

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

         A_      :				str		     =					10

         # no processor list
         def run_no_processor_list(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		):
           A_      :				int		     =					temp_dist_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Optional[Any]		     =					top_k_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				List[Any]		     =					top_p_warp(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Dict		     =					min_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Any		     =					bos_dist_proc(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           A_      :				Optional[Any]		     =					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		):
           A_      :				Optional[int]		     =					FlaxLogitsProcessorList(
               [temp_dist_warp, top_k_warp, top_p_warp, min_dist_proc, bos_dist_proc, eos_dist_proc]		)
           A_      :				Optional[int]		     =					processor(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       cur_len=_SCREAMING_SNAKE_CASE		)
           return scores

         A_      :				Optional[int]		     =					jax.jit(_SCREAMING_SNAKE_CASE		)
         A_      :				Union[str, Any]		     =					jax.jit(_SCREAMING_SNAKE_CASE		)

         A_      :				Dict		     =					jitted_run_no_processor_list(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)
         A_      :				List[Any]		     =					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()		)




