




import random
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    import PIL

    from transformers import FlavaImageProcessor
    from transformers.image_utils import PILImageResampling
    from transformers.models.flava.image_processing_flava import (
        FLAVA_CODEBOOK_MEAN,
        FLAVA_CODEBOOK_STD,
        FLAVA_IMAGE_MEAN,
        FLAVA_IMAGE_STD,
    )
else:
    _lowerCamelCase							=      None


class        UpperCAmelCase__				(							unittest.TestCase				):



     '''simple docstring'''
     def __init__(				self ,    _lowerCAmelCase ,    _lowerCAmelCase=7 ,    _lowerCAmelCase=3 ,    _lowerCAmelCase=30 ,    _lowerCAmelCase=400 ,    _lowerCAmelCase=True ,    _lowerCAmelCase=None ,    _lowerCAmelCase=True ,    _lowerCAmelCase=None ,    _lowerCAmelCase=None ,    _lowerCAmelCase=True ,    _lowerCAmelCase=1 / 255 ,    _lowerCAmelCase=True ,    _lowerCAmelCase=FLAVA_IMAGE_MEAN ,    _lowerCAmelCase=FLAVA_IMAGE_STD ,    _lowerCAmelCase=14 ,    _lowerCAmelCase=75 ,    _lowerCAmelCase=None ,    _lowerCAmelCase=16 ,    _lowerCAmelCase=0.3 ,    _lowerCAmelCase=None ,    _lowerCAmelCase=True ,    _lowerCAmelCase=None ,    _lowerCAmelCase=None ,    _lowerCAmelCase=True ,    _lowerCAmelCase=None ,    _lowerCAmelCase=True ,    _lowerCAmelCase=True ,    _lowerCAmelCase=FLAVA_CODEBOOK_MEAN ,    _lowerCAmelCase=FLAVA_CODEBOOK_STD ,    ):
            a			   =size if size is not None else {"""height""": 224, """width""": 224}
            a			   =crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
            a			   =codebook_size if codebook_size is not None else {"""height""": 112, """width""": 112}
            a			   =codebook_crop_size if codebook_crop_size is not None else {"""height""": 112, """width""": 112}

            a			   =parent
            a			   =batch_size
            a			   =num_channels
            a			   =do_resize
            a			   =do_rescale
            a			   =rescale_factor
            a			   =min_resolution
            a			   =max_resolution
            a			   =size
            a			   =resample if resample is not None else PILImageResampling.BICUBIC
            a			   =do_normalize
            a			   =image_mean
            a			   =image_std
            a			   =do_center_crop
            a			   =crop_size

            a			   =input_size_patches
            a			   =total_mask_patches
            a			   =mask_group_max_patches
            a			   =mask_group_min_patches
            a			   =mask_group_min_aspect_ratio
            a			   =mask_group_max_aspect_ratio

            a			   =codebook_do_resize
            a			   =codebook_size
            a			   =codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
            a			   =codebook_do_center_crop
            a			   =codebook_crop_size
            a			   =codebook_do_map_pixels
            a			   =codebook_do_normalize
            a			   =codebook_image_mean
            a			   =codebook_image_std
     def        lowerCAmelCase__  (				self	):
            return {
                "image_mean": self.image_mean,
                "image_std": self.image_std,
                "do_normalize": self.do_normalize,
                "do_resize": self.do_resize,
                "size": self.size,
                "resample": self.resample,
                "do_rescale": self.do_rescale,
                "rescale_factor": self.rescale_factor,
                "do_center_crop": self.do_center_crop,
                "crop_size": self.crop_size,
                "input_size_patches": self.input_size_patches,
                "total_mask_patches": self.total_mask_patches,
                "mask_group_max_patches": self.mask_group_max_patches,
                "mask_group_min_patches": self.mask_group_min_patches,
                "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
                "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
                "codebook_do_resize": self.codebook_do_resize,
                "codebook_size": self.codebook_size,
                "codebook_resample": self.codebook_resample,
                "codebook_do_center_crop": self.codebook_do_center_crop,
                "codebook_crop_size": self.codebook_crop_size,
                "codebook_do_map_pixels": self.codebook_do_map_pixels,
                "codebook_do_normalize": self.codebook_do_normalize,
                "codebook_image_mean": self.codebook_image_mean,
                "codebook_image_std": self.codebook_image_std,
            }
     def        lowerCAmelCase__  (				self	):
            return (self.size["height"], self.size["width"])
     def        lowerCAmelCase__  (				self	):
            return (
                (self.input_size_patches, self.input_size_patches)
                if not isinstance(self.input_size_patches ,    __UpperCAmelCase	)
                else self.input_size_patches
            )






     def        lowerCAmelCase__  (				self	):
            return (self.codebook_size["height"], self.codebook_size["width"])



@require_torch
@require_vision
class        UpperCAmelCase__				(							lowerCamelCase_      ,		unittest.TestCase				):



     '''simple docstring'''
     _SCREAMING_SNAKE_CASE      :					List[str]     					=    FlavaImageProcessor if is_vision_available() else None
     _SCREAMING_SNAKE_CASE      :					Tuple     					=    None
     def        lowerCAmelCase__  (				self	):
            a			   =FlavaImageProcessingTester(self	)
     @property
     def        lowerCAmelCase__  (				self	):
            return self.image_processor_tester.prepare_image_processor_dict()
     def        lowerCAmelCase__  (				self	):
            a			   =self.image_processing_class(**self.image_processor_dict	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """image_mean"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """image_std"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """do_normalize"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """do_resize"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """resample"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """crop_size"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """do_center_crop"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """do_rescale"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """rescale_factor"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """masking_generator"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_do_resize"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_size"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_resample"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_do_center_crop"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_crop_size"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_do_map_pixels"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_do_normalize"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_image_mean"""	)	)
            self.assertTrue(hasattr(__UpperCAmelCase ,    """codebook_image_std"""	)	)
     def        lowerCAmelCase__  (				self	):
            a			   =self.image_processing_class.from_dict(self.image_processor_dict	)
            self.assertEqual(image_processor.size ,    {"""height""": 224, """width""": 224}	)
            self.assertEqual(image_processor.crop_size ,    {"""height""": 224, """width""": 224}	)
            self.assertEqual(image_processor.codebook_size ,    {"""height""": 112, """width""": 112}	)
            self.assertEqual(image_processor.codebook_crop_size ,    {"""height""": 112, """width""": 112}	)

            a			   =self.image_processing_class.from_dict(
                self.image_processor_dict ,    size=42 ,    crop_size=84 ,    codebook_size=33 ,    codebook_crop_size=66	)
            self.assertEqual(image_processor.size ,    {"""height""": 42, """width""": 42}	)
            self.assertEqual(image_processor.crop_size ,    {"""height""": 84, """width""": 84}	)
            self.assertEqual(image_processor.codebook_size ,    {"""height""": 33, """width""": 33}	)
            self.assertEqual(image_processor.codebook_crop_size ,    {"""height""": 66, """width""": 66}	)
     def        lowerCAmelCase__  (				self	):
            pass
     def        lowerCAmelCase__  (				self	):
            a			   =self.image_processing_class(**self.image_processor_dict	)
            # create random PIL images
            a			   =prepare_image_inputs(self.image_processor_tester ,    equal_resolution=__UpperCAmelCase	)
            for image in image_inputs:
                   self.assertIsInstance(__UpperCAmelCase ,    PIL.Image.Image	)

            # Test not batched input
            a			   =image_processing(image_inputs[0] ,    return_tensors="""pt"""	)

            # Test no bool masked pos
            self.assertFalse("""bool_masked_pos""" in encoded_images	)

            a   ,      a			   =self.image_processor_tester.get_expected_image_size()

            self.assertEqual(
                encoded_images.pixel_values.shape ,    (1, self.image_processor_tester.num_channels, expected_height, expected_width) ,    )

            # Test batched
            a			   =image_processing(__UpperCAmelCase ,    return_tensors="""pt"""	)
            a   ,      a			   =self.image_processor_tester.get_expected_image_size()

            # Test no bool masked pos
            self.assertFalse("""bool_masked_pos""" in encoded_images	)

            self.assertEqual(
                encoded_images.pixel_values.shape ,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                ) ,    )
     def        lowerCAmelCase__  (				self ,    _lowerCAmelCase ,    _lowerCAmelCase	):
            a			   =self.image_processing_class(**self.image_processor_dict	)
            # create random tensors
            a			   =prepare_image_inputs(self.image_processor_tester ,    equal_resolution=__UpperCAmelCase ,    **__UpperCAmelCase	)
            for image in image_inputs:
                   self.assertIsInstance(__UpperCAmelCase ,    __UpperCAmelCase	)

            # Test not batched input
            a			   =image_processing(image_inputs[0] ,    return_tensors="""pt"""	)

            a   ,      a			   =self.image_processor_tester.get_expected_image_size()
            self.assertEqual(
                encoded_images.pixel_values.shape ,    (1, self.image_processor_tester.num_channels, expected_height, expected_width) ,    )

            a			   =image_processing(__UpperCAmelCase ,    return_image_mask=__UpperCAmelCase ,    return_tensors="""pt"""	)

            a   ,      a			   =self.image_processor_tester.get_expected_image_size()
            self.assertEqual(
                encoded_images.pixel_values.shape ,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                ) ,    )

            a   ,      a			   =self.image_processor_tester.get_expected_mask_size()
            self.assertEqual(
                encoded_images.bool_masked_pos.shape ,    (
                    self.image_processor_tester.batch_size,
                    expected_height,
                    expected_width,
                ) ,    )

            # Test batched
            a			   =image_processing(__UpperCAmelCase ,    return_tensors="""pt"""	).pixel_values

            a   ,      a			   =self.image_processor_tester.get_expected_image_size()
            self.assertEqual(
                encoded_images.shape ,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                ) ,    )

            # Test masking
            a			   =image_processing(__UpperCAmelCase ,    return_image_mask=__UpperCAmelCase ,    return_tensors="""pt"""	)

            a   ,      a			   =self.image_processor_tester.get_expected_image_size()
            self.assertEqual(
                encoded_images.pixel_values.shape ,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                ) ,    )

            a   ,      a			   =self.image_processor_tester.get_expected_mask_size()
            self.assertEqual(
                encoded_images.bool_masked_pos.shape ,    (
                    self.image_processor_tester.batch_size,
                    expected_height,
                    expected_width,
                ) ,    )
     def        lowerCAmelCase__  (				self	):
            self._test_call_framework(np.ndarray ,    prepare_kwargs={"""numpify""": True}	)
     def        lowerCAmelCase__  (				self	):
            self._test_call_framework(torch.Tensor ,    prepare_kwargs={"""torchify""": True}	)
     def        lowerCAmelCase__  (				self	):
            random.seed(1_234	)
            a			   =self.image_processing_class(**self.image_processor_dict	)
            a			   =prepare_image_inputs(self.image_processor_tester ,    equal_resolution=__UpperCAmelCase ,    torchify=__UpperCAmelCase	)

            # Test not batched input
            a			   =image_processing(image_inputs[0] ,    return_image_mask=__UpperCAmelCase ,    return_tensors="""pt"""	)
            self.assertEqual(encoded_images.bool_masked_pos.sum().item() ,    75	)






     def        lowerCAmelCase__  (				self	):
            a			   =self.image_processing_class(**self.image_processor_dict	)
            # create random PIL images
            a			   =prepare_image_inputs(self.image_processor_tester ,    equal_resolution=__UpperCAmelCase	)
            for image in image_inputs:
                   self.assertIsInstance(__UpperCAmelCase ,    PIL.Image.Image	)

            # Test not batched input
            a			   =image_processing(image_inputs[0] ,    return_codebook_pixels=__UpperCAmelCase ,    return_tensors="""pt"""	)
            a   ,      a			   =self.image_processor_tester.get_expected_codebook_image_size()
            self.assertEqual(
                encoded_images.codebook_pixel_values.shape ,    (1, self.image_processor_tester.num_channels, expected_height, expected_width) ,    )

            # Test batched
            a			   =image_processing(__UpperCAmelCase ,    return_codebook_pixels=__UpperCAmelCase ,    return_tensors="""pt"""	)
            a   ,      a			   =self.image_processor_tester.get_expected_codebook_image_size()
            self.assertEqual(
                encoded_images.codebook_pixel_values.shape ,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                ) ,    )






from typing import TYPE_CHECKING

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


__a			:	List[Any]							     =		{
    """configuration_utils""": ["""GenerationConfig"""],
    """streamers""": ["""TextIteratorStreamer""", """TextStreamer"""],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__a			:	Dict							     =		[
				    """Constraint""",
				    """ConstraintListState""",
				    """DisjunctiveConstraint""",
				    """PhrasalConstraint""",
				]
				__a			:	int							     =		[
				    """BeamHypotheses""",
				    """BeamScorer""",
				    """BeamSearchScorer""",
				    """ConstrainedBeamSearchScorer""",
				]
				__a			:	List[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""",
				]
				__a			:	Any							     =		[
				    """MaxNewTokensCriteria""",
				    """MaxLengthCriteria""",
				    """MaxTimeCriteria""",
				    """StoppingCriteria""",
				    """StoppingCriteriaList""",
				    """validate_stopping_criteria""",
				]
				__a			:	str							     =		[
				    """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:
				__a			:	List[Any]							     =		[
				    """TFForcedBOSTokenLogitsProcessor""",
				    """TFForcedEOSTokenLogitsProcessor""",
				    """TFLogitsProcessor""",
				    """TFLogitsProcessorList""",
				    """TFLogitsWarper""",
				    """TFMinLengthLogitsProcessor""",
				    """TFNoBadWordsLogitsProcessor""",
				    """TFNoRepeatNGramLogitsProcessor""",
				    """TFRepetitionPenaltyLogitsProcessor""",
				    """TFTemperatureLogitsWarper""",
				    """TFTopKLogitsWarper""",
				    """TFTopPLogitsWarper""",
				    """TFForceTokensLogitsProcessor""",
				    """TFSuppressTokensAtBeginLogitsProcessor""",
				    """TFSuppressTokensLogitsProcessor""",
				]
				__a			:	Any							     =		[
				    """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:
				__a			:	str							     =		[
				    """FlaxForcedBOSTokenLogitsProcessor""",
				    """FlaxForcedEOSTokenLogitsProcessor""",
				    """FlaxLogitsProcessor""",
				    """FlaxLogitsProcessorList""",
				    """FlaxLogitsWarper""",
				    """FlaxMinLengthLogitsProcessor""",
				    """FlaxTemperatureLogitsWarper""",
				    """FlaxTopKLogitsWarper""",
				    """FlaxTopPLogitsWarper""",
				]
				__a			:	Tuple							     =		[
				    """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

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