
'''simple docstring'''
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__   :		Dict 		=get_logger(__name__)


A__   :		Any 		=r'\n    Args:\n        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):\n            Indices of input sequence tokens in the vocabulary.\n\n            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n            [`PreTrainedTokenizer.__call__`] for details.\n\n            [What are input IDs?](../glossary#input-ids)\n        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):\n            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam\n            search or log softmax for each vocabulary token when using beam search\n        kwargs (`Dict[str, Any]`, *optional*):\n            Additional logits processor specific kwargs.\n\n    Return:\n        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.\n\n'







class  __A				:
 @add_start_docstrings(lowerCamelCase       )
 def __call__(   self			:    int				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray       ):



   """simple docstring"""





   raise NotImplementedError(
       f"{self.__class__} is an abstract class. Only classes inheriting this class can be called."       )







class  __A				:
 @add_start_docstrings(lowerCamelCase       )
 def __call__(   self			:    Tuple				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray       ):



   """simple docstring"""





   raise NotImplementedError(
       f"{self.__class__} is an abstract class. Only classes inheriting this class can be called."       )







class  __A				( _SCREAMING_SNAKE_CASE			):
 @add_start_docstrings(lowerCamelCase       )
 def __call__(   self			:    List[str]				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int				,   **lowerCamelCase			:    str       ):



   """simple docstring"""





   for processor in self:
     __A		:     List[str]												=		inspect.signature(processor.__call__       ).parameters
     if len(lowerCamelCase       ) > 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."       )
       __A		:     Union[str, Any]												=		processor(lowerCamelCase				,   lowerCamelCase				,   lowerCamelCase				,   **lowerCamelCase       )
     else:
       __A		:     str												=		processor(lowerCamelCase				,   lowerCamelCase				,   lowerCamelCase       )
   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Union[str, Any]				,   lowerCamelCase			:    float       ):



   """simple docstring"""





   if not isinstance(lowerCamelCase				,   lowerCamelCase       ) or not (temperature > 0):
     raise ValueError(f"`temperature` has to be a strictly positive float, but is {temperature}"       )

   __A		:     List[str]												=		temperature






 def __call__(   self			:    Optional[Any]				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     List[str]												=		scores / self.temperature
   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Dict				,   lowerCamelCase			:    float				,   lowerCamelCase			:    float = -float("""Inf"""       )				,   lowerCamelCase			:    int = 1       ):



   """simple docstring"""





   if not isinstance(lowerCamelCase				,   lowerCamelCase       ) 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(lowerCamelCase				,   lowerCamelCase       ) 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}"       )

   __A		:     Dict												=		top_p
   __A		:     int												=		filter_value
   __A		:     List[Any]												=		min_tokens_to_keep






 def __call__(   self			:    Dict				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A							,					__A		:     Tuple												=		lax.top_k(lowerCamelCase				,   scores.shape[-1]       )

   __A		:     List[str]												=		jnp.full_like(lowerCamelCase				,   self.filter_value       )
   __A		:     Any												=		jax.nn.softmax(lowerCamelCase				,   axis=-1       ).cumsum(axis=-1       )
   __A		:     Optional[Any]												=		cumulative_probs < self.top_p

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

   # min tokens to keep
   __A		:     Any												=		score_mask.at[:, : self.min_tokens_to_keep].set(lowerCamelCase       )

   __A		:     List[str]												=		jnp.where(lowerCamelCase				,   lowerCamelCase				,   lowerCamelCase       )
   __A		:     Dict												=		jax.lax.sort_key_val(lowerCamelCase				,   lowerCamelCase       )[-1]

   return next_scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Any				,   lowerCamelCase			:    int				,   lowerCamelCase			:    float = -float("""Inf"""       )				,   lowerCamelCase			:    int = 1       ):



   """simple docstring"""





   if not isinstance(lowerCamelCase				,   lowerCamelCase       ) or top_k <= 0:
     raise ValueError(f"`top_k` has to be a strictly positive integer, but is {top_k}"       )

   __A		:     int												=		max(lowerCamelCase				,   lowerCamelCase       )
   __A		:     Tuple												=		filter_value






 def __call__(   self			:    List[Any]				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A							,					__A		:     Dict												=		scores.shape
   __A		:     Optional[int]												=		jnp.full(batch_size * vocab_size				,   self.filter_value       )

   __A		:     str												=		min(self.top_k				,   scores.shape[-1]       )  # Safety check
   __A							,					__A		:     Tuple												=		lax.top_k(lowerCamelCase				,   lowerCamelCase       )
   __A		:     Dict												=		jnp.broadcast_to((jnp.arange(lowerCamelCase       ) * vocab_size)[:, None]				,   (batch_size, topk)       ).flatten()
   __A		:     Dict												=		topk_scores.flatten()
   __A		:     Dict												=		topk_indices.flatten() + shift

   __A		:     List[str]												=		next_scores_flat.at[topk_indices_flat].set(lowerCamelCase       )
   __A		:     Optional[int]												=		next_scores_flat.reshape(lowerCamelCase				,   lowerCamelCase       )
   return next_scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Dict				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     Dict												=		bos_token_id






 def __call__(   self			:    Optional[int]				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     List[str]												=		jnp.full(scores.shape				,   -float("""inf"""       )       )

   __A		:     List[str]												=		1 - jnp.bool_(cur_len - 1       )

   __A		:     Union[str, Any]												=		jnp.where(lowerCamelCase				,   new_scores.at[:, self.bos_token_id].set(0       )				,   lowerCamelCase       )

   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    str				,   lowerCamelCase			:    int				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     Any												=		max_length
   __A		:     Any												=		eos_token_id






 def __call__(   self			:    List[str]				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     Optional[int]												=		jnp.full(scores.shape				,   -float("""inf"""       )       )

   __A		:     Optional[int]												=		1 - jnp.bool_(cur_len - self.max_length + 1       )

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

   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Optional[Any]				,   lowerCamelCase			:    int				,   lowerCamelCase			:    int       ):



   """simple docstring"""





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

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

   __A		:     Optional[Any]												=		min_length
   __A		:     List[str]												=		eos_token_id






 def __call__(   self			:    List[str]				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     Any												=		1 - jnp.clip(cur_len - self.min_length				,   0				,   1       )

   __A		:     List[Any]												=		jnp.where(lowerCamelCase				,   scores.at[:, self.eos_token_id].set(-float("""inf"""       )       )				,   lowerCamelCase       )

   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Union[str, Any]				,   lowerCamelCase			:    Any				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     str												=		list(lowerCamelCase       )
   __A		:     Dict												=		begin_index






 def __call__(   self			:    Union[str, Any]				,   lowerCamelCase			:    List[str]				,   lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     int												=		1 - jnp.bool_(cur_len - self.begin_index       )

   __A		:     str												=		jnp.where(lowerCamelCase				,   scores.at[:, self.begin_suppress_tokens].set(-float("""inf"""       )       )				,   lowerCamelCase       )

   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    int				,   lowerCamelCase			:    list       ):



   """simple docstring"""





   __A		:     Any												=		list(lowerCamelCase       )






 def __call__(   self			:    Optional[int]				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   __A		:     Any												=		scores.at[..., self.suppress_tokens].set(-float("""inf"""       )       )

   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Optional[int]				,   lowerCamelCase			:    Optional[int]       ):



   """simple docstring"""





   __A		:     Tuple												=		dict(lowerCamelCase       )
   # 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.
   __A		:     List[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:
       __A		:     int												=		force_token_array.at[index].set(lowerCamelCase       )
   __A		:     str												=		jnp.intaa(lowerCamelCase       )






 def __call__(   self			:    int				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    jnp.ndarray				,   lowerCamelCase			:    int       ):



   """simple docstring"""





   def _force_token(lowerCamelCase			:    Union[str, Any]       ):
     __A		:     Dict												=		scores.shape[0]
     __A		:     str												=		self.force_token_array[generation_idx]

     __A		:     Union[str, Any]												=		jnp.ones_like(lowerCamelCase				,   dtype=scores.dtype       ) * -float("""inf"""       )
     __A		:     Optional[int]												=		jnp.zeros((batch_size, 1)				,   dtype=scores.dtype       )
     __A		:     str												=		lax.dynamic_update_slice(lowerCamelCase				,   lowerCamelCase				,   (0, current_token)       )
     return new_scores

   __A		:     int												=		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(lowerCamelCase       )				,   lambda: scores				,   )				,   )
   return scores







class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    int				,   lowerCamelCase			:    List[Any]				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Union[str, Any]       ):



   """simple docstring"""





   __A		:     Tuple												=		generate_config.eos_token_id
   __A		:     Any												=		generate_config.no_timestamps_token_id
   __A		:     Tuple												=		generate_config.no_timestamps_token_id + 1

   __A		:     Optional[Any]												=		decoder_input_length + 1

   if generate_config.is_multilingual:
     # room for language token and task token
     self.begin_index += 2
   if hasattr(lowerCamelCase				,   """max_initial_timestamp_index"""       ):
     __A		:     Optional[int]												=		generate_config.max_initial_timestamp_index
   else:
     __A		:     List[str]												=		model_config.vocab_size
   if self.max_initial_timestamp_index is None:
     __A		:     List[str]												=		model_config.vocab_size






 def __call__(   self			:    Dict				,   lowerCamelCase			:    List[str]				,   lowerCamelCase			:    Union[str, Any]				,   lowerCamelCase			:    Union[str, Any]       ):



   """simple docstring"""





   __A		:     Optional[Any]												=		scores.at[:, self.no_timestamps_token_id].set(-float("""inf"""       )       )

   def handle_pairs(lowerCamelCase			:    Tuple				,   lowerCamelCase			:    List[Any]       ):
     __A		:     List[str]												=		jnp.where((cur_len - self.begin_index) >= 1				,   lowerCamelCase				,   lowerCamelCase       )
     __A		:     Any												=		jnp.where(
         input_ids_k[cur_len - 1] >= self.timestamp_begin				,   True and last_was_timestamp				,   lowerCamelCase				,   )

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

     return jnp.where(
         lowerCamelCase				,   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"""       )       )				,   )				,   lowerCamelCase				,   )

   __A		:     str												=		jax.vmap(lowerCamelCase       )(lowerCamelCase				,   lowerCamelCase       )

   __A		:     Optional[Any]												=		jnp.where(cur_len == self.begin_index				,   lowerCamelCase				,   lowerCamelCase       )
   __A		:     Tuple												=		jnp.where(
       self.max_initial_timestamp_index is not None				,   True and apply_max_initial_timestamp				,   lowerCamelCase				,   )

   __A		:     int												=		self.timestamp_begin + self.max_initial_timestamp_index

   __A		:     List[Any]												=		jnp.where(
       lowerCamelCase				,   scores.at[:, last_allowed + 1 :].set(-float("""inf"""       )       )				,   lowerCamelCase				,   )

   # if sum of probability over timestamps is above any other token, sample timestamp
   __A		:     List[Any]												=		jax.nn.log_softmax(lowerCamelCase				,   axis=-1       )

   def handle_cumulative_probs(lowerCamelCase			:    Tuple				,   lowerCamelCase			:    List[str]       ):
     __A		:     Optional[Any]												=		jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]				,   axis=-1       )
     __A		:     List[str]												=		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"""       )       )				,   lowerCamelCase				,   )

   __A		:     Optional[int]												=		jax.vmap(lowerCamelCase       )(lowerCamelCase				,   lowerCamelCase       )

   return scores





'''simple docstring'''
from packaging import version

from .import_utils import is_accelerate_available


if is_accelerate_available():
     import accelerate







def        A_     (						__SCREAMING_SNAKE_CASE						:  Dict )				->       Optional[int]:





  """simple docstring"""

  if not is_accelerate_available():
    return method
  __A		:     int												=		version.parse(accelerate.__version__ ).base_version
  if version.parse(__SCREAMING_SNAKE_CASE ) < version.parse("""0.17.0""" ):
    return method

  def wrapper(self						:  str			,     *__SCREAMING_SNAKE_CASE						:  Tuple			,     **__SCREAMING_SNAKE_CASE						:  Tuple ):
    if hasattr(self			,     """_hf_hook""" ) and hasattr(self._hf_hook			,     """pre_forward""" ):
      self._hf_hook.pre_forward(self )
    return method(self			,     *__SCREAMING_SNAKE_CASE			,     **__SCREAMING_SNAKE_CASE )

  return wrapper



