






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_		:    Optional[Any]   							=     get_logger(__name__)


a_		:    Dict   							=     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 		_snake_case	:






			@add_start_docstrings(a)
			def __call__(							self		,       a		,       a)   ->							jnp.ndarray:
						raise NotImplementedError(
						    f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.''')



class 		_snake_case	:






			@add_start_docstrings(a)
			def __call__(							self		,       a		,       a)   ->							jnp.ndarray:
						raise NotImplementedError(
						    f'''{self.__class__} is an abstract class. Only classes inheriting this class can be called.''')



class 		_snake_case	(	A__       ):






			@add_start_docstrings(a)
			def __call__(							self		,       a		,       a		,       a		,       **a)   ->							jnp.ndarray:
						for processor in self:
									SCREAMING_SNAKE_CASE							=			inspect.signature(processor.__call__).parameters
									if len(a) > 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.''')
												SCREAMING_SNAKE_CASE							=			processor(a		,       a		,       a		,       **a)
									else:
												SCREAMING_SNAKE_CASE							=			processor(a		,       a		,       a)
						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a)   ->							List[str]:
						if not isinstance(a		,       a) or not (temperature > 0):
									raise ValueError(f'''`temperature` has to be a strictly positive float, but is {temperature}''')

						SCREAMING_SNAKE_CASE							=			temperature







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						SCREAMING_SNAKE_CASE							=			scores / self.temperature
						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a		,       a = -float('Inf')		,       a = 1)   ->							Optional[Any]:
						if not isinstance(a		,       a) 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(a		,       a) 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}''')

						SCREAMING_SNAKE_CASE							=			top_p
						SCREAMING_SNAKE_CASE							=			filter_value
						SCREAMING_SNAKE_CASE							=			min_tokens_to_keep







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			lax.top_k(a		,       scores.shape[-1])

						SCREAMING_SNAKE_CASE							=			jnp.full_like(a		,       self.filter_value)
						SCREAMING_SNAKE_CASE							=			jax.nn.softmax(a		,       axis=-1).cumsum(axis=-1)
						SCREAMING_SNAKE_CASE							=			cumulative_probs < self.top_p

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

						# min tokens to keep
						SCREAMING_SNAKE_CASE							=			score_mask.at[:, : self.min_tokens_to_keep].set(a)

						SCREAMING_SNAKE_CASE							=			jnp.where(a		,       a		,       a)
						SCREAMING_SNAKE_CASE							=			jax.lax.sort_key_val(a		,       a)[-1]

						return next_scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a		,       a = -float('Inf')		,       a = 1)   ->							int:
						if not isinstance(a		,       a) or top_k <= 0:
									raise ValueError(f'''`top_k` has to be a strictly positive integer, but is {top_k}''')

						SCREAMING_SNAKE_CASE							=			max(a		,       a)
						SCREAMING_SNAKE_CASE							=			filter_value







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			scores.shape
						SCREAMING_SNAKE_CASE							=			jnp.full(batch_size * vocab_size		,       self.filter_value)

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

						SCREAMING_SNAKE_CASE							=			next_scores_flat.at[topk_indices_flat].set(a)
						SCREAMING_SNAKE_CASE							=			next_scores_flat.reshape(a		,       a)
						return next_scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a)   ->							Any:
						SCREAMING_SNAKE_CASE							=			bos_token_id







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						SCREAMING_SNAKE_CASE							=			jnp.full(scores.shape		,       -float('inf'))

						SCREAMING_SNAKE_CASE							=			1 - jnp.bool_(cur_len - 1)

						SCREAMING_SNAKE_CASE							=			jnp.where(a		,       new_scores.at[:, self.bos_token_id].set(0)		,       a)

						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a		,       a)   ->							int:
						SCREAMING_SNAKE_CASE							=			max_length
						SCREAMING_SNAKE_CASE							=			eos_token_id







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						SCREAMING_SNAKE_CASE							=			jnp.full(scores.shape		,       -float('inf'))

						SCREAMING_SNAKE_CASE							=			1 - jnp.bool_(cur_len - self.max_length + 1)

						SCREAMING_SNAKE_CASE							=			jnp.where(a		,       new_scores.at[:, self.eos_token_id].set(0)		,       a)

						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a		,       a)   ->							int:
						if not isinstance(a		,       a) or min_length < 0:
									raise ValueError(f'''`min_length` has to be a positive integer, but is {min_length}''')

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

						SCREAMING_SNAKE_CASE							=			min_length
						SCREAMING_SNAKE_CASE							=			eos_token_id







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						# create boolean flag to decide if min length penalty should be applied
						SCREAMING_SNAKE_CASE							=			1 - jnp.clip(cur_len - self.min_length		,       0		,       1)

						SCREAMING_SNAKE_CASE							=			jnp.where(a		,       scores.at[:, self.eos_token_id].set(-float('inf'))		,       a)

						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a		,       a)   ->							Any:
						SCREAMING_SNAKE_CASE							=			list(a)
						SCREAMING_SNAKE_CASE							=			begin_index







			def __call__(							self		,       a		,       a		,       a)   ->							List[str]:
						SCREAMING_SNAKE_CASE							=			1 - jnp.bool_(cur_len - self.begin_index)

						SCREAMING_SNAKE_CASE							=			jnp.where(a		,       scores.at[:, self.begin_suppress_tokens].set(-float('inf'))		,       a)

						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a)   ->							Any:
						SCREAMING_SNAKE_CASE							=			list(a)







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						SCREAMING_SNAKE_CASE							=			scores.at[..., self.suppress_tokens].set(-float('inf'))

						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a)   ->							int:
						SCREAMING_SNAKE_CASE							=			dict(a)
						# 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.
						SCREAMING_SNAKE_CASE							=			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:
												SCREAMING_SNAKE_CASE							=			force_token_array.at[index].set(a)
						SCREAMING_SNAKE_CASE							=			jnp.intaa(a)







			def __call__(							self		,       a		,       a		,       a)   ->							jnp.ndarray:
						def _force_token(a):
									SCREAMING_SNAKE_CASE							=			scores.shape[0]
									SCREAMING_SNAKE_CASE							=			self.force_token_array[generation_idx]

									SCREAMING_SNAKE_CASE							=			jnp.ones_like(a		,       dtype=scores.dtype) * -float('inf')
									SCREAMING_SNAKE_CASE							=			jnp.zeros((batch_size, 1)		,       dtype=scores.dtype)
									SCREAMING_SNAKE_CASE							=			lax.dynamic_update_slice(a		,       a		,       (0, current_token))
									return new_scores

						SCREAMING_SNAKE_CASE							=			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(a)		,       lambda: scores		,       )		,       )
						return scores



class 		_snake_case	(	A__       ):






			def __init__(							self		,       a		,       a		,       a)   ->							List[str]:
						SCREAMING_SNAKE_CASE							=			generate_config.eos_token_id
						SCREAMING_SNAKE_CASE							=			generate_config.no_timestamps_token_id
						SCREAMING_SNAKE_CASE							=			generate_config.no_timestamps_token_id + 1

						SCREAMING_SNAKE_CASE							=			decoder_input_length + 1

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







			def __call__(							self		,       a		,       a		,       a)   ->							Tuple:
						# suppress <|notimestamps|> which is handled by without_timestamps
						SCREAMING_SNAKE_CASE							=			scores.at[:, self.no_timestamps_token_id].set(-float('inf'))

						def handle_pairs(a		,       a):
									SCREAMING_SNAKE_CASE							=			jnp.where((cur_len - self.begin_index) >= 1		,       a		,       a)
									SCREAMING_SNAKE_CASE							=			jnp.where(
									    input_ids_k[cur_len - 1] >= self.timestamp_begin		,       True and last_was_timestamp		,       a		,       )

									SCREAMING_SNAKE_CASE							=			jnp.where((cur_len - self.begin_index) < 2		,       a		,       a)
									SCREAMING_SNAKE_CASE							=			jnp.where(
									    input_ids_k[cur_len - 2] >= self.timestamp_begin		,       a		,       a		,       )

									return jnp.where(
									    a		,       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'))		,       )		,       a		,       )

						SCREAMING_SNAKE_CASE							=			jax.vmap(a)(a		,       a)

						SCREAMING_SNAKE_CASE							=			jnp.where(cur_len == self.begin_index		,       a		,       a)
						SCREAMING_SNAKE_CASE							=			jnp.where(
						    self.max_initial_timestamp_index is not None		,       True and apply_max_initial_timestamp		,       a		,       )

						SCREAMING_SNAKE_CASE							=			self.timestamp_begin + self.max_initial_timestamp_index

						SCREAMING_SNAKE_CASE							=			jnp.where(
						    a		,       scores.at[:, last_allowed + 1 :].set(-float('inf'))		,       a		,       )

						# if sum of probability over timestamps is above any other token, sample timestamp
						SCREAMING_SNAKE_CASE							=			jax.nn.log_softmax(a		,       axis=-1)

						def handle_cumulative_probs(a		,       a):
									SCREAMING_SNAKE_CASE							=			jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]		,       axis=-1)
									SCREAMING_SNAKE_CASE							=			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'))		,       a		,       )

						SCREAMING_SNAKE_CASE							=			jax.vmap(a)(a		,       a)

						return scores










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__magic_name__  :  Union[str, Any]					=       {
    """configuration_altclip""": [
        """ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AltCLIPConfig""",
        """AltCLIPTextConfig""",
        """AltCLIPVisionConfig""",
    ],
    """processing_altclip""": ["""AltCLIPProcessor"""],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __magic_name__  :  str					=       [
          """ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """AltCLIPPreTrainedModel""",
          """AltCLIPModel""",
          """AltCLIPTextModel""",
          """AltCLIPVisionModel""",
      ]


if TYPE_CHECKING:
      from .configuration_altclip import (
          ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
          AltCLIPConfig,
          AltCLIPTextConfig,
          AltCLIPVisionConfig,
      )
      from .processing_altclip import AltCLIPProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_altclip import (
                ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
                AltCLIPModel,
                AltCLIPPreTrainedModel,
                AltCLIPTextModel,
                AltCLIPVisionModel,
            )


else:
      import sys

      __magic_name__  :  str					=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

