'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFXLMForMultipleChoice,
      TFXLMForQuestionAnsweringSimple,
      TFXLMForSequenceClassification,
      TFXLMForTokenClassification,
      TFXLMModel,
      TFXLMWithLMHeadModel,
      XLMConfig,
  )




class 	__UpperCAmelCase				:





       '''simple docstring'''



       def __init__(      self    ,     _SCREAMING_SNAKE_CASE    ,     )		->     Dict:
           A_     =   parent
           A_     =   13
           A_     =   7
           A_     =   True
           A_     =   True
           A_     =   True
           A_     =   True
           A_     =   True
           A_     =   False
           A_     =   False
           A_     =   False
           A_     =   2
           A_     =   99
           A_     =   0
           A_     =   32
           A_     =   2
           A_     =   4
           A_     =   0.1
           A_     =   0.1
           A_     =   512
           A_     =   16
           A_     =   2
           A_     =   0.02
           A_     =   3
           A_     =   4
           A_     =   """last"""
           A_     =   True
           A_     =   None
           A_     =   0

       def 					__A       (      self )		->     Optional[int]:
           A_     =   ids_tensor([self.batch_size, self.seq_length]    ,     self.vocab_size )
           A_     =   random_attention_mask([self.batch_size, self.seq_length]    ,     dtype=tf.floataa )

           A_     =   None
           if self.use_input_lengths:
               A_     =   (
                   ids_tensor([self.batch_size]    ,     vocab_size=2 ) + self.seq_length - 2
               )  # small variation of seq_length

           A_     =   None
           if self.use_token_type_ids:
               A_     =   ids_tensor([self.batch_size, self.seq_length]    ,     self.n_langs )

           A_     =   None
           A_     =   None
           A_     =   None
           if self.use_labels:
               A_     =   ids_tensor([self.batch_size]    ,     self.type_sequence_label_size )
               A_     =   ids_tensor([self.batch_size, self.seq_length]    ,     self.num_labels )
               A_     =   ids_tensor([self.batch_size]    ,     2    ,     dtype=tf.floataa )
               A_     =   ids_tensor([self.batch_size]    ,     self.num_choices )

           A_     =   XLMConfig(
               vocab_size=self.vocab_size    ,     n_special=self.n_special    ,     emb_dim=self.hidden_size    ,     n_layers=self.num_hidden_layers    ,     n_heads=self.num_attention_heads    ,     dropout=self.hidden_dropout_prob    ,     attention_dropout=self.attention_probs_dropout_prob    ,     gelu_activation=self.gelu_activation    ,     sinusoidal_embeddings=self.sinusoidal_embeddings    ,     asm=self.asm    ,     causal=self.causal    ,     n_langs=self.n_langs    ,     max_position_embeddings=self.max_position_embeddings    ,     initializer_range=self.initializer_range    ,     summary_type=self.summary_type    ,     use_proj=self.use_proj    ,     bos_token_id=self.bos_token_id    ,     )

           return (
               config,
               input_ids,
               token_type_ids,
               input_lengths,
               sequence_labels,
               token_labels,
               is_impossible_labels,
               choice_labels,
               input_mask,
           )

       def 					__A       (      self    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     )		->     Optional[int]:
           A_     =   TFXLMModel(config=UpperCAmelCase_ )
           A_     =   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
           A_     =   model(UpperCAmelCase_ )

           A_     =   [input_ids, input_mask]
           A_     =   model(UpperCAmelCase_ )
           self.parent.assertEqual(result.last_hidden_state.shape    ,     (self.batch_size, self.seq_length, self.hidden_size) )

       def 					__A       (      self    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     )		->     Union[str, Any]:
           A_     =   TFXLMWithLMHeadModel(UpperCAmelCase_ )

           A_     =   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
           A_     =   model(UpperCAmelCase_ )

           A_     =   outputs

           self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.seq_length, self.vocab_size) )

       def 					__A       (      self    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     )		->     Union[str, Any]:
           A_     =   TFXLMForQuestionAnsweringSimple(UpperCAmelCase_ )

           A_     =   {"""input_ids""": input_ids, """lengths""": input_lengths}

           A_     =   model(UpperCAmelCase_ )

           self.parent.assertEqual(result.start_logits.shape    ,     (self.batch_size, self.seq_length) )
           self.parent.assertEqual(result.end_logits.shape    ,     (self.batch_size, self.seq_length) )

       def 					__A       (      self    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     )		->     Union[str, Any]:
           A_     =   TFXLMForSequenceClassification(UpperCAmelCase_ )

           A_     =   {"""input_ids""": input_ids, """lengths""": input_lengths}

           A_     =   model(UpperCAmelCase_ )

           self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.type_sequence_label_size) )

       def 					__A       (      self    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     )		->     Optional[Any]:
           A_     =   self.num_labels
           A_     =   TFXLMForTokenClassification(config=UpperCAmelCase_ )
           A_     =   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
           A_     =   model(UpperCAmelCase_ )
           self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.seq_length, self.num_labels) )

       def 					__A       (      self    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     )		->     Optional[int]:
           A_     =   self.num_choices
           A_     =   TFXLMForMultipleChoice(config=UpperCAmelCase_ )
           A_     =   tf.tile(tf.expand_dims(UpperCAmelCase_    ,     1 )    ,     (1, self.num_choices, 1) )
           A_     =   tf.tile(tf.expand_dims(UpperCAmelCase_    ,     1 )    ,     (1, self.num_choices, 1) )
           A_     =   tf.tile(tf.expand_dims(UpperCAmelCase_    ,     1 )    ,     (1, self.num_choices, 1) )
           A_     =   {
               """input_ids""": multiple_choice_inputs_ids,
               """attention_mask""": multiple_choice_input_mask,
               """token_type_ids""": multiple_choice_token_type_ids,
           }
           A_     =   model(UpperCAmelCase_ )
           self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.num_choices) )

       def 					__A       (      self )		->     str:
           A_     =   self.prepare_config_and_inputs()
           (
               A_   
           )     =   config_and_inputs
           A_     =   {
               """input_ids""": input_ids,
               """token_type_ids""": token_type_ids,
               """langs""": token_type_ids,
               """lengths""": input_lengths,
           }
           return config, inputs_dict




@require_tf
class 	__UpperCAmelCase				(				_UpperCamelCase						,      _UpperCamelCase						,      unittest.TestCase     ):





       '''simple docstring'''



       __lowercase					:					Optional[Any]    =				(
           (
               TFXLMModel,
               TFXLMWithLMHeadModel,
               TFXLMForSequenceClassification,
               TFXLMForQuestionAnsweringSimple,
               TFXLMForTokenClassification,
               TFXLMForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       __lowercase					:					List[str]    =				(
           (TFXLMWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       __lowercase					:					int    =				(
           {
               "feature-extraction": TFXLMModel,
               "fill-mask": TFXLMWithLMHeadModel,
               "question-answering": TFXLMForQuestionAnsweringSimple,
               "text-classification": TFXLMForSequenceClassification,
               "text-generation": TFXLMWithLMHeadModel,
               "token-classification": TFXLMForTokenClassification,
               "zero-shot": TFXLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __lowercase					:					Tuple    =				False
       __lowercase					:					str    =				False

       def 					__A       (      self    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE    ,     _SCREAMING_SNAKE_CASE )		->     str:
           if (
               pipeline_test_casse_name == "QAPipelineTests"
               and tokenizer_name is not None
               and not tokenizer_name.endswith('''Fast''' )
           ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

           return False

       def 					__A       (      self )		->     str:
           A_     =   TFXLMModelTester(self )
           A_     =   ConfigTester(self    ,     config_class=UpperCAmelCase_    ,     emb_dim=37 )

       def 					__A       (      self )		->     Any:
           self.config_tester.run_common_tests()

       def 					__A       (      self )		->     Tuple:
           A_     =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_model(*UpperCAmelCase_ )

       def 					__A       (      self )		->     Union[str, Any]:
           A_     =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase_ )

       def 					__A       (      self )		->     Union[str, Any]:
           A_     =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase_ )

       def 					__A       (      self )		->     Any:
           A_     =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase_ )

       def 					__A       (      self )		->     List[Any]:
           A_     =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_token_classification(*UpperCAmelCase_ )

       def 					__A       (      self )		->     Optional[int]:
           A_     =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase_ )

       @slow
       def 					__A       (      self )		->     List[Any]:
           for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               A_     =   TFXLMModel.from_pretrained(UpperCAmelCase_ )
               self.assertIsNotNone(UpperCAmelCase_ )




@require_tf
class 	__UpperCAmelCase				(				unittest.TestCase     ):





       '''simple docstring'''



       @slow
       def 					__A       (      self )		->     int:
           A_     =   TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048''' )
           A_     =   tf.convert_to_tensor([[14, 447]]    ,     dtype=tf.intaa )  # the president
           A_     =   [
               14,
               447,
               14,
               447,
               14,
               447,
               14,
               447,
               14,
               447,
               14,
               447,
               14,
               447,
               14,
               447,
               14,
               447,
               14,
               447,
           ]  # the president the president the president the president the president the president the president the president the president the president
           # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
           A_     =   model.generate(UpperCAmelCase_    ,     do_sample=UpperCAmelCase_ )
           self.assertListEqual(output_ids[0].numpy().tolist()    ,     UpperCAmelCase_ )











"""simple docstring"""







from typing import TYPE_CHECKING

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


UpperCAmelCase:   int       			=							{
    """configuration_utils""": ["""GenerationConfig"""],
    """streamers""": ["""TextIteratorStreamer""", """TextStreamer"""],
}

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

		UpperCAmelCase:   Optional[Any]       			=							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



