
'''simple docstring'''
from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


__SCREAMING_SNAKE_CASE				:							Optional[Any]		       =		{
    '''configuration_utils''': ['''GenerationConfig'''],
    '''streamers''': ['''TextIteratorStreamer''', '''TextStreamer'''],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE				:							List[Any]		       =		[
							    '''Constraint''',
							    '''ConstraintListState''',
							    '''DisjunctiveConstraint''',
							    '''PhrasalConstraint''',
							]
							__SCREAMING_SNAKE_CASE				:							Union[str, Any]		       =		[
							    '''BeamHypotheses''',
							    '''BeamScorer''',
							    '''BeamSearchScorer''',
							    '''ConstrainedBeamSearchScorer''',
							]
							__SCREAMING_SNAKE_CASE				:							Tuple		       =		[
							    '''EpsilonLogitsWarper''',
							    '''EtaLogitsWarper''',
							    '''ForcedBOSTokenLogitsProcessor''',
							    '''ForcedEOSTokenLogitsProcessor''',
							    '''HammingDiversityLogitsProcessor''',
							    '''InfNanRemoveLogitsProcessor''',
							    '''LogitsProcessor''',
							    '''LogitsProcessorList''',
							    '''LogitsWarper''',
							    '''MinLengthLogitsProcessor''',
							    '''MinNewTokensLengthLogitsProcessor''',
							    '''NoBadWordsLogitsProcessor''',
							    '''NoRepeatNGramLogitsProcessor''',
							    '''PrefixConstrainedLogitsProcessor''',
							    '''RepetitionPenaltyLogitsProcessor''',
							    '''SequenceBiasLogitsProcessor''',
							    '''EncoderRepetitionPenaltyLogitsProcessor''',
							    '''TemperatureLogitsWarper''',
							    '''TopKLogitsWarper''',
							    '''TopPLogitsWarper''',
							    '''TypicalLogitsWarper''',
							    '''EncoderNoRepeatNGramLogitsProcessor''',
							    '''ExponentialDecayLengthPenalty''',
							    '''LogitNormalization''',
							]
							__SCREAMING_SNAKE_CASE				:							Union[str, Any]		       =		[
							    '''MaxNewTokensCriteria''',
							    '''MaxLengthCriteria''',
							    '''MaxTimeCriteria''',
							    '''StoppingCriteria''',
							    '''StoppingCriteriaList''',
							    '''validate_stopping_criteria''',
							]
							__SCREAMING_SNAKE_CASE				:							List[Any]		       =		[
							    '''GenerationMixin''',
							    '''top_k_top_p_filtering''',
							    '''GreedySearchEncoderDecoderOutput''',
							    '''GreedySearchDecoderOnlyOutput''',
							    '''SampleEncoderDecoderOutput''',
							    '''SampleDecoderOnlyOutput''',
							    '''BeamSearchEncoderDecoderOutput''',
							    '''BeamSearchDecoderOnlyOutput''',
							    '''BeamSampleEncoderDecoderOutput''',
							    '''BeamSampleDecoderOnlyOutput''',
							    '''ContrastiveSearchEncoderDecoderOutput''',
							    '''ContrastiveSearchDecoderOnlyOutput''',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		[
							    '''TFForcedBOSTokenLogitsProcessor''',
							    '''TFForcedEOSTokenLogitsProcessor''',
							    '''TFLogitsProcessor''',
							    '''TFLogitsProcessorList''',
							    '''TFLogitsWarper''',
							    '''TFMinLengthLogitsProcessor''',
							    '''TFNoBadWordsLogitsProcessor''',
							    '''TFNoRepeatNGramLogitsProcessor''',
							    '''TFRepetitionPenaltyLogitsProcessor''',
							    '''TFTemperatureLogitsWarper''',
							    '''TFTopKLogitsWarper''',
							    '''TFTopPLogitsWarper''',
							    '''TFForceTokensLogitsProcessor''',
							    '''TFSuppressTokensAtBeginLogitsProcessor''',
							    '''TFSuppressTokensLogitsProcessor''',
							]
							__SCREAMING_SNAKE_CASE				:							Tuple		       =		[
							    '''TFGenerationMixin''',
							    '''tf_top_k_top_p_filtering''',
							    '''TFGreedySearchDecoderOnlyOutput''',
							    '''TFGreedySearchEncoderDecoderOutput''',
							    '''TFSampleEncoderDecoderOutput''',
							    '''TFSampleDecoderOnlyOutput''',
							    '''TFBeamSearchEncoderDecoderOutput''',
							    '''TFBeamSearchDecoderOnlyOutput''',
							    '''TFBeamSampleEncoderDecoderOutput''',
							    '''TFBeamSampleDecoderOnlyOutput''',
							    '''TFContrastiveSearchEncoderDecoderOutput''',
							    '''TFContrastiveSearchDecoderOnlyOutput''',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE				:							int		       =		[
							    '''FlaxForcedBOSTokenLogitsProcessor''',
							    '''FlaxForcedEOSTokenLogitsProcessor''',
							    '''FlaxLogitsProcessor''',
							    '''FlaxLogitsProcessorList''',
							    '''FlaxLogitsWarper''',
							    '''FlaxMinLengthLogitsProcessor''',
							    '''FlaxTemperatureLogitsWarper''',
							    '''FlaxTopKLogitsWarper''',
							    '''FlaxTopPLogitsWarper''',
							]
							__SCREAMING_SNAKE_CASE				:							List[Any]		       =		[
							    '''FlaxGenerationMixin''',
							    '''FlaxGreedySearchOutput''',
							    '''FlaxSampleOutput''',
							    '''FlaxBeamSearchOutput''',
							]

if TYPE_CHECKING:
							from .configuration_utils import GenerationConfig
							from .streamers import TextIteratorStreamer, TextStreamer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
														from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
														from .logits_process import (
														    EncoderNoRepeatNGramLogitsProcessor,
														    EncoderRepetitionPenaltyLogitsProcessor,
														    EpsilonLogitsWarper,
														    EtaLogitsWarper,
														    ExponentialDecayLengthPenalty,
														    ForcedBOSTokenLogitsProcessor,
														    ForcedEOSTokenLogitsProcessor,
														    HammingDiversityLogitsProcessor,
														    InfNanRemoveLogitsProcessor,
														    LogitNormalization,
														    LogitsProcessor,
														    LogitsProcessorList,
														    LogitsWarper,
														    MinLengthLogitsProcessor,
														    MinNewTokensLengthLogitsProcessor,
														    NoBadWordsLogitsProcessor,
														    NoRepeatNGramLogitsProcessor,
														    PrefixConstrainedLogitsProcessor,
														    RepetitionPenaltyLogitsProcessor,
														    SequenceBiasLogitsProcessor,
														    TemperatureLogitsWarper,
														    TopKLogitsWarper,
														    TopPLogitsWarper,
														    TypicalLogitsWarper,
														)
														from .stopping_criteria import (
														    MaxLengthCriteria,
														    MaxNewTokensCriteria,
														    MaxTimeCriteria,
														    StoppingCriteria,
														    StoppingCriteriaList,
														    validate_stopping_criteria,
														)
														from .utils import (
														    BeamSampleDecoderOnlyOutput,
														    BeamSampleEncoderDecoderOutput,
														    BeamSearchDecoderOnlyOutput,
														    BeamSearchEncoderDecoderOutput,
														    ContrastiveSearchDecoderOnlyOutput,
														    ContrastiveSearchEncoderDecoderOutput,
														    GenerationMixin,
														    GreedySearchDecoderOnlyOutput,
														    GreedySearchEncoderDecoderOutput,
														    SampleDecoderOnlyOutput,
														    SampleEncoderDecoderOutput,
														    top_k_top_p_filtering,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tf_logits_process import (
														    TFForcedBOSTokenLogitsProcessor,
														    TFForcedEOSTokenLogitsProcessor,
														    TFForceTokensLogitsProcessor,
														    TFLogitsProcessor,
														    TFLogitsProcessorList,
														    TFLogitsWarper,
														    TFMinLengthLogitsProcessor,
														    TFNoBadWordsLogitsProcessor,
														    TFNoRepeatNGramLogitsProcessor,
														    TFRepetitionPenaltyLogitsProcessor,
														    TFSuppressTokensAtBeginLogitsProcessor,
														    TFSuppressTokensLogitsProcessor,
														    TFTemperatureLogitsWarper,
														    TFTopKLogitsWarper,
														    TFTopPLogitsWarper,
														)
														from .tf_utils import (
														    TFBeamSampleDecoderOnlyOutput,
														    TFBeamSampleEncoderDecoderOutput,
														    TFBeamSearchDecoderOnlyOutput,
														    TFBeamSearchEncoderDecoderOutput,
														    TFContrastiveSearchDecoderOnlyOutput,
														    TFContrastiveSearchEncoderDecoderOutput,
														    TFGenerationMixin,
														    TFGreedySearchDecoderOnlyOutput,
														    TFGreedySearchEncoderDecoderOutput,
														    TFSampleDecoderOnlyOutput,
														    TFSampleEncoderDecoderOutput,
														    tf_top_k_top_p_filtering,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .flax_logits_process import (
														    FlaxForcedBOSTokenLogitsProcessor,
														    FlaxForcedEOSTokenLogitsProcessor,
														    FlaxLogitsProcessor,
														    FlaxLogitsProcessorList,
														    FlaxLogitsWarper,
														    FlaxMinLengthLogitsProcessor,
														    FlaxTemperatureLogitsWarper,
														    FlaxTopKLogitsWarper,
														    FlaxTopPLogitsWarper,
														)
														from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
							import sys

							__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)









'''simple docstring'''
import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
							import tensorflow as tf

							from transformers.activations_tf import get_tf_activation






@require_tf
class 				__lowerCAmelCase      (      unittest.TestCase	):

						"""simple docstring"""






						def 							_UpperCAmelCase					(     self       :			List[Any]  ):
													A_ 						=		tf.constant([-1_00, -1.0, -0.1, 0, 0.1, 1.0, 1_0_0.0]  )
													A_ 						=		get_tf_activation("gelu"  )
													A_ 						=		get_tf_activation("gelu_10"  )

													A_ 						=		gelu(lowerCAmelCase  )
													A_ 						=		geluaa(lowerCAmelCase  )

													A_ 						=		tf.where(y_gelu_aa < 1_0.0   ,     1.0   ,     0.0  )

													self.assertEqual(tf.math.reduce_max(lowerCAmelCase  ).numpy().item()   ,     1_0.0  )
													self.assertTrue(np.allclose(y_gelu * clipped_mask   ,     y_gelu_aa * clipped_mask  )  )






						def 							_UpperCAmelCase					(     self       :			Union[str, Any]  ):
													get_tf_activation("gelu"  )
													get_tf_activation("gelu_10"  )
													get_tf_activation("gelu_fast"  )
													get_tf_activation("gelu_new"  )
													get_tf_activation("glu"  )
													get_tf_activation("mish"  )
													get_tf_activation("quick_gelu"  )
													get_tf_activation("relu"  )
													get_tf_activation("sigmoid"  )
													get_tf_activation("silu"  )
													get_tf_activation("swish"  )
													get_tf_activation("tanh"  )
													with self.assertRaises(lowerCAmelCase  ):
																				get_tf_activation("bogus"  )
													with self.assertRaises(lowerCAmelCase  ):
																				get_tf_activation(lowerCAmelCase  )





