

import inspect

import jax
import jax.lax as lax
import jax.numpy as jnp

from ..utils import add_start_docstrings
from ..utils.logging import get_logger


a		=get_logger(__name__)


a		=r"""
    Args:
        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):
            Indices of input sequence tokens in the vocabulary.

            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):
            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam
            search or log softmax for each vocabulary token when using beam search
        kwargs (`Dict[str, Any]`, *optional*):
            Additional logits processor specific kwargs.

    Return:
        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.

"""






class        A_		:
							@add_start_docstrings(UpperCAmelCase__)
							def __call__(		self		:			Dict   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray):
								raise NotImplementedError(
								    F"{self.__class__} is an abstract class. Only classes inheriting this class can be called.")






class        A_		:
							@add_start_docstrings(UpperCAmelCase__)
							def __call__(		self		:			str   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray):
								raise NotImplementedError(
								    F"{self.__class__} is an abstract class. Only classes inheriting this class can be called.")






class        A_		(       __lowercase				):
							@add_start_docstrings(UpperCAmelCase__)
							def __call__(		self		:			int   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int   ,**SCREAMING_SNAKE_CASE__		:			Tuple):
								for processor in self:
									__lowerCamelCase				:				Tuple					       = inspect.signature(processor.__call__).parameters
									if len(UpperCAmelCase__) > 3:
										if not all(arg in kwargs for arg in list(function_args.keys())[2:]):
											raise ValueError(
											    F"Make sure that all the required parameters: {list(function_args.keys())} for "
											    F"{processor.__class__} are passed to the logits processor.")
										__lowerCamelCase				:				str					       = processor(UpperCAmelCase__   ,UpperCAmelCase__   ,UpperCAmelCase__   ,**UpperCAmelCase__)
									else:
										__lowerCamelCase				:				Optional[Any]					       = processor(UpperCAmelCase__   ,UpperCAmelCase__   ,UpperCAmelCase__)
								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			float):
								if not isinstance(UpperCAmelCase__   ,UpperCAmelCase__) or not (temperature > 0):
									raise ValueError(F"`temperature` has to be a strictly positive float, but is {temperature}")

								__lowerCamelCase				:				Any					       = temperature


							def __call__(		self		:			Any   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				Dict					       = scores / self.temperature
								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			float   ,SCREAMING_SNAKE_CASE__		:			float = -float('Inf')   ,SCREAMING_SNAKE_CASE__		:			int = 1):
								if not isinstance(UpperCAmelCase__   ,UpperCAmelCase__) or (top_p < 0 or top_p > 1.0):
									raise ValueError(F"`top_p` has to be a float > 0 and < 1, but is {top_p}")
								if not isinstance(UpperCAmelCase__   ,UpperCAmelCase__) or (min_tokens_to_keep < 1):
									raise ValueError(F"`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}")

								__lowerCamelCase				:				Union[str, Any]					       = top_p
								__lowerCamelCase				:				int					       = filter_value
								__lowerCamelCase				:				Any					       = min_tokens_to_keep


							def __call__(		self		:			str   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase       , __lowerCamelCase				:				Dict					       = lax.top_k(UpperCAmelCase__   ,scores.shape[-1])

								__lowerCamelCase				:				Tuple					       = jnp.full_like(UpperCAmelCase__   ,self.filter_value)
								__lowerCamelCase				:				Dict					       = jax.nn.softmax(UpperCAmelCase__   ,axis=-1).cumsum(axis=-1)
								__lowerCamelCase				:				Tuple					       = cumulative_probs < self.top_p

								# include the token that is higher than top_p as well
								__lowerCamelCase				:				Union[str, Any]					       = jnp.roll(UpperCAmelCase__   ,1)
								score_mask |= score_mask.at[:, 0].set(UpperCAmelCase__)

								# min tokens to keep
								__lowerCamelCase				:				Optional[int]					       = score_mask.at[:, : self.min_tokens_to_keep].set(UpperCAmelCase__)

								__lowerCamelCase				:				Optional[int]					       = jnp.where(UpperCAmelCase__   ,UpperCAmelCase__   ,UpperCAmelCase__)
								__lowerCamelCase				:				Optional[int]					       = jax.lax.sort_key_val(UpperCAmelCase__   ,UpperCAmelCase__)[-1]

								return next_scores






class        A_		(       __lowercase				):
							def __init__(		self		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			float = -float('Inf')   ,SCREAMING_SNAKE_CASE__		:			int = 1):
								if not isinstance(UpperCAmelCase__   ,UpperCAmelCase__) or top_k <= 0:
									raise ValueError(F"`top_k` has to be a strictly positive integer, but is {top_k}")

								__lowerCamelCase				:				List[Any]					       = max(UpperCAmelCase__   ,UpperCAmelCase__)
								__lowerCamelCase				:				List[str]					       = filter_value


							def __call__(		self		:			int   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase       , __lowerCamelCase				:				Optional[int]					       = scores.shape
								__lowerCamelCase				:				int					       = jnp.full(batch_size * vocab_size   ,self.filter_value)

								__lowerCamelCase				:				Optional[int]					       = min(self.top_k   ,scores.shape[-1])  # Safety check
								__lowerCamelCase       , __lowerCamelCase				:				Optional[Any]					       = lax.top_k(UpperCAmelCase__   ,UpperCAmelCase__)
								__lowerCamelCase				:				int					       = jnp.broadcast_to((jnp.arange(UpperCAmelCase__) * vocab_size)[:, None]   ,(batch_size, topk)).flatten()
								__lowerCamelCase				:				int					       = topk_scores.flatten()
								__lowerCamelCase				:				Dict					       = topk_indices.flatten() + shift

								__lowerCamelCase				:				Union[str, Any]					       = next_scores_flat.at[topk_indices_flat].set(UpperCAmelCase__)
								__lowerCamelCase				:				Dict					       = next_scores_flat.reshape(UpperCAmelCase__   ,UpperCAmelCase__)
								return next_scores






class        A_		(       __lowercase				):
							def __init__(		self		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				Dict					       = bos_token_id


							def __call__(		self		:			Dict   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				Optional[int]					       = jnp.full(scores.shape   ,-float('inf'))

								__lowerCamelCase				:				Union[str, Any]					       = 1 - jnp.bool_(cur_len - 1)

								__lowerCamelCase				:				List[str]					       = jnp.where(UpperCAmelCase__   ,new_scores.at[:, self.bos_token_id].set(0)   ,UpperCAmelCase__)

								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			int   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				Optional[Any]					       = max_length
								__lowerCamelCase				:				List[Any]					       = eos_token_id


							def __call__(		self		:			str   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				Optional[Any]					       = jnp.full(scores.shape   ,-float('inf'))

								__lowerCamelCase				:				Any					       = 1 - jnp.bool_(cur_len - self.max_length + 1)

								__lowerCamelCase				:				str					       = jnp.where(UpperCAmelCase__   ,new_scores.at[:, self.eos_token_id].set(0)   ,UpperCAmelCase__)

								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			int):
								if not isinstance(UpperCAmelCase__   ,UpperCAmelCase__) or min_length < 0:
									raise ValueError(F"`min_length` has to be a positive integer, but is {min_length}")

								if not isinstance(UpperCAmelCase__   ,UpperCAmelCase__) or eos_token_id < 0:
									raise ValueError(F"`eos_token_id` has to be a positive integer, but is {eos_token_id}")

								__lowerCamelCase				:				str					       = min_length
								__lowerCamelCase				:				Any					       = eos_token_id


							def __call__(		self		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								# create boolean flag to decide if min length penalty should be applied
								__lowerCamelCase				:				Union[str, Any]					       = 1 - jnp.clip(cur_len - self.min_length   ,0   ,1)

								__lowerCamelCase				:				Union[str, Any]					       = jnp.where(UpperCAmelCase__   ,scores.at[:, self.eos_token_id].set(-float('inf'))   ,UpperCAmelCase__)

								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			List[str]):
								__lowerCamelCase				:				Union[str, Any]					       = list(UpperCAmelCase__)
								__lowerCamelCase				:				str					       = begin_index


							def __call__(		self		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			List[str]   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				int					       = 1 - jnp.bool_(cur_len - self.begin_index)

								__lowerCamelCase				:				Tuple					       = jnp.where(UpperCAmelCase__   ,scores.at[:, self.begin_suppress_tokens].set(-float('inf'))   ,UpperCAmelCase__)

								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			List[Any]   ,SCREAMING_SNAKE_CASE__		:			list):
								__lowerCamelCase				:				List[str]					       = list(UpperCAmelCase__)


							def __call__(		self		:			Optional[int]   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								__lowerCamelCase				:				str					       = scores.at[..., self.suppress_tokens].set(-float('inf'))

								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			Optional[Any]   ,SCREAMING_SNAKE_CASE__		:			List[Any]):
								__lowerCamelCase				:				str					       = dict(UpperCAmelCase__)
								# Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the
								# index of the array corresponds to the index of the token to be forced, for XLA compatibility.
								# Indexes without forced tokens will have a negative value.
								__lowerCamelCase				:				str					       = jnp.ones((max(force_token_map.keys()) + 1)   ,dtype=jnp.intaa) * -1
								for index, token in force_token_map.items():
									if token is not None:
										__lowerCamelCase				:				Dict					       = force_token_array.at[index].set(UpperCAmelCase__)
								__lowerCamelCase				:				str					       = jnp.intaa(UpperCAmelCase__)


							def __call__(		self		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			jnp.ndarray   ,SCREAMING_SNAKE_CASE__		:			int):
								def _force_token(SCREAMING_SNAKE_CASE__		:			Optional[int]):
									__lowerCamelCase				:				Optional[int]					       = scores.shape[0]
									__lowerCamelCase				:				Union[str, Any]					       = self.force_token_array[generation_idx]

									__lowerCamelCase				:				List[str]					       = jnp.ones_like(UpperCAmelCase__   ,dtype=scores.dtype) * -float('inf')
									__lowerCamelCase				:				Tuple					       = jnp.zeros((batch_size, 1)   ,dtype=scores.dtype)
									__lowerCamelCase				:				Tuple					       = lax.dynamic_update_slice(UpperCAmelCase__   ,UpperCAmelCase__   ,(0, current_token))
									return new_scores

								__lowerCamelCase				:				str					       = lax.cond(
								    cur_len >= self.force_token_array.shape[0]   ,lambda: scores   ,lambda: lax.cond(
								        self.force_token_array[cur_len] >= 0   ,lambda: _force_token(UpperCAmelCase__)   ,lambda: scores   ,)   ,)
								return scores






class        A_		(       __lowercase				):
							def __init__(		self		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			List[Any]   ,SCREAMING_SNAKE_CASE__		:			int   ,SCREAMING_SNAKE_CASE__		:			List[str]):
								__lowerCamelCase				:				List[Any]					       = generate_config.eos_token_id
								__lowerCamelCase				:				Dict					       = generate_config.no_timestamps_token_id
								__lowerCamelCase				:				Optional[Any]					       = generate_config.no_timestamps_token_id + 1

								__lowerCamelCase				:				List[str]					       = decoder_input_length + 1

								if generate_config.is_multilingual:
									# room for language token and task token
									self.begin_index += 2
								if hasattr(UpperCAmelCase__   ,'max_initial_timestamp_index'):
									__lowerCamelCase				:				int					       = generate_config.max_initial_timestamp_index
								else:
									__lowerCamelCase				:				str					       = model_config.vocab_size
								if self.max_initial_timestamp_index is None:
									__lowerCamelCase				:				Any					       = model_config.vocab_size


							def __call__(		self		:			List[Any]   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			Tuple   ,SCREAMING_SNAKE_CASE__		:			Optional[int]):
								# suppress <|notimestamps|> which is handled by without_timestamps
								__lowerCamelCase				:				Optional[Any]					       = scores.at[:, self.no_timestamps_token_id].set(-float('inf'))

								def handle_pairs(SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			str):
									__lowerCamelCase				:				List[str]					       = jnp.where((cur_len - self.begin_index) >= 1   ,UpperCAmelCase__   ,UpperCAmelCase__)
									__lowerCamelCase				:				List[Any]					       = jnp.where(
									    input_ids_k[cur_len - 1] >= self.timestamp_begin   ,True and last_was_timestamp   ,UpperCAmelCase__   ,)

									__lowerCamelCase				:				Optional[int]					       = jnp.where((cur_len - self.begin_index) < 2   ,UpperCAmelCase__   ,UpperCAmelCase__)
									__lowerCamelCase				:				int					       = jnp.where(
									    input_ids_k[cur_len - 2] >= self.timestamp_begin   ,UpperCAmelCase__   ,UpperCAmelCase__   ,)

									return jnp.where(
									    UpperCAmelCase__   ,jnp.where(
									        penultimate_was_timestamp > 0   ,scores_k.at[self.timestamp_begin :].set(-float('inf'))   ,scores_k.at[: self.eos_token_id].set(-float('inf'))   ,)   ,UpperCAmelCase__   ,)

								__lowerCamelCase				:				str					       = jax.vmap(UpperCAmelCase__)(UpperCAmelCase__   ,UpperCAmelCase__)

								__lowerCamelCase				:				Tuple					       = jnp.where(cur_len == self.begin_index   ,UpperCAmelCase__   ,UpperCAmelCase__)
								__lowerCamelCase				:				Optional[int]					       = jnp.where(
								    self.max_initial_timestamp_index is not None   ,True and apply_max_initial_timestamp   ,UpperCAmelCase__   ,)

								__lowerCamelCase				:				Optional[int]					       = self.timestamp_begin + self.max_initial_timestamp_index

								__lowerCamelCase				:				Optional[int]					       = jnp.where(
								    UpperCAmelCase__   ,scores.at[:, last_allowed + 1 :].set(-float('inf'))   ,UpperCAmelCase__   ,)

								# if sum of probability over timestamps is above any other token, sample timestamp
								__lowerCamelCase				:				Optional[int]					       = jax.nn.log_softmax(UpperCAmelCase__   ,axis=-1)

								def handle_cumulative_probs(SCREAMING_SNAKE_CASE__		:			Union[str, Any]   ,SCREAMING_SNAKE_CASE__		:			str):
									__lowerCamelCase				:				int					       = jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]   ,axis=-1)
									__lowerCamelCase				:				Optional[Any]					       = jnp.max(logprobs_k[: self.timestamp_begin])
									return jnp.where(
									    timestamp_logprob > max_text_token_logprob   ,scores_k.at[: self.timestamp_begin].set(-float('inf'))   ,UpperCAmelCase__   ,)

								__lowerCamelCase				:				Tuple					       = jax.vmap(UpperCAmelCase__)(UpperCAmelCase__   ,UpperCAmelCase__)

								return scores








'''simple docstring'''




import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu

@require_cpu
class 		UpperCAmelCase_      (  unittest.TestCase		):





     def 							__UpperCAmelCase      ( self       :      str    )				->  List[Any]:
        lowerCAmelCase     =			torch.nn.Linear(1_0    ,      1_0    )
        lowerCAmelCase     =			torch.optim.SGD(model.parameters()    ,      0.1    )
        lowerCAmelCase     =			Accelerator()
        lowerCAmelCase     =			accelerator.prepare(UpperCAmelCase__    )
        try:
           pickle.loads(pickle.dumps(UpperCAmelCase__    )    )
        except Exception as e:
           self.fail(F'''Accelerated optimizer pickling failed with {e}'''    )
        AcceleratorState._reset_state()





