from typing import TYPE_CHECKING

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


snake_case__						      =			{
    '''configuration_utils''': ['''GenerationConfig'''],
    '''streamers''': ['''TextIteratorStreamer''', '''TextStreamer'''],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case__						      =			[
         '''Constraint''',
         '''ConstraintListState''',
         '''DisjunctiveConstraint''',
         '''PhrasalConstraint''',
     ]
     snake_case__						      =			[
         '''BeamHypotheses''',
         '''BeamScorer''',
         '''BeamSearchScorer''',
         '''ConstrainedBeamSearchScorer''',
     ]
     snake_case__						      =			[
         '''EpsilonLogitsWarper''',
         '''EtaLogitsWarper''',
         '''ForcedBOSTokenLogitsProcessor''',
         '''ForcedEOSTokenLogitsProcessor''',
         '''HammingDiversityLogitsProcessor''',
         '''InfNanRemoveLogitsProcessor''',
         '''LogitsProcessor''',
         '''LogitsProcessorList''',
         '''LogitsWarper''',
         '''MinLengthLogitsProcessor''',
         '''MinNewTokensLengthLogitsProcessor''',
         '''NoBadWordsLogitsProcessor''',
         '''NoRepeatNGramLogitsProcessor''',
         '''PrefixConstrainedLogitsProcessor''',
         '''RepetitionPenaltyLogitsProcessor''',
         '''SequenceBiasLogitsProcessor''',
         '''EncoderRepetitionPenaltyLogitsProcessor''',
         '''TemperatureLogitsWarper''',
         '''TopKLogitsWarper''',
         '''TopPLogitsWarper''',
         '''TypicalLogitsWarper''',
         '''EncoderNoRepeatNGramLogitsProcessor''',
         '''ExponentialDecayLengthPenalty''',
         '''LogitNormalization''',
     ]
     snake_case__						      =			[
         '''MaxNewTokensCriteria''',
         '''MaxLengthCriteria''',
         '''MaxTimeCriteria''',
         '''StoppingCriteria''',
         '''StoppingCriteriaList''',
         '''validate_stopping_criteria''',
     ]
     snake_case__						      =			[
         '''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:
     snake_case__						      =			[
         '''TFForcedBOSTokenLogitsProcessor''',
         '''TFForcedEOSTokenLogitsProcessor''',
         '''TFLogitsProcessor''',
         '''TFLogitsProcessorList''',
         '''TFLogitsWarper''',
         '''TFMinLengthLogitsProcessor''',
         '''TFNoBadWordsLogitsProcessor''',
         '''TFNoRepeatNGramLogitsProcessor''',
         '''TFRepetitionPenaltyLogitsProcessor''',
         '''TFTemperatureLogitsWarper''',
         '''TFTopKLogitsWarper''',
         '''TFTopPLogitsWarper''',
         '''TFForceTokensLogitsProcessor''',
         '''TFSuppressTokensAtBeginLogitsProcessor''',
         '''TFSuppressTokensLogitsProcessor''',
     ]
     snake_case__						      =			[
         '''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:
     snake_case__						      =			[
         '''FlaxForcedBOSTokenLogitsProcessor''',
         '''FlaxForcedEOSTokenLogitsProcessor''',
         '''FlaxLogitsProcessor''',
         '''FlaxLogitsProcessorList''',
         '''FlaxLogitsWarper''',
         '''FlaxMinLengthLogitsProcessor''',
         '''FlaxTemperatureLogitsWarper''',
         '''FlaxTopKLogitsWarper''',
         '''FlaxTopPLogitsWarper''',
     ]
     snake_case__						      =			[
         '''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

     snake_case__						      =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


__SCREAMING_SNAKE_CASE	:							str           =  {
    '''configuration_ernie_m''': ['''ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ErnieMConfig'''],
}

try:
		if not is_sentencepiece_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__SCREAMING_SNAKE_CASE	:							Any           =  ['''ErnieMTokenizer''']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__SCREAMING_SNAKE_CASE	:							Tuple           =  [
		    '''ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''ErnieMForMultipleChoice''',
		    '''ErnieMForQuestionAnswering''',
		    '''ErnieMForSequenceClassification''',
		    '''ErnieMForTokenClassification''',
		    '''ErnieMModel''',
		    '''ErnieMPreTrainedModel''',
		    '''ErnieMForInformationExtraction''',
		]


if TYPE_CHECKING:
		from .configuration_ernie_m import ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieMConfig

		try:
				if not is_sentencepiece_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_ernie_m import ErnieMTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_ernie_m import (
				    ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ErnieMForInformationExtraction,
				    ErnieMForMultipleChoice,
				    ErnieMForQuestionAnswering,
				    ErnieMForSequenceClassification,
				    ErnieMForTokenClassification,
				    ErnieMModel,
				    ErnieMPreTrainedModel,
				)


else:
		import sys

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

