
"""simple docstring"""


import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import DonutSwinModel
		from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST







class 			lowerCAmelCase_			:



						'''simple docstring'''


						def __init__(	self       : Tuple					,A_       : List[str]					,A_       : int=13					,A_       : Optional[int]=32					,A_       : Union[str, Any]=2					,A_       : Union[str, Any]=3					,A_       : str=16					,A_       : Union[str, Any]=[1, 2, 1]					,A_       : List[str]=[2, 2, 4]					,A_       : Optional[int]=2					,A_       : int=2.0					,A_       : Optional[Any]=True					,A_       : List[str]=0.0					,A_       : List[str]=0.0					,A_       : Dict=0.1					,A_       : Union[str, Any]="gelu"					,A_       : Any=False					,A_       : Any=True					,A_       : Optional[int]=0.02					,A_       : Union[str, Any]=1e-5					,A_       : Any=True					,A_       : int=None					,A_       : List[Any]=True					,A_       : Any=10					,A_       : Tuple=8					,)       ->				List[str]:
							A  				=				parent
							A  				=				batch_size
							A  				=				image_size
							A  				=				patch_size
							A  				=				num_channels
							A  				=				embed_dim
							A  				=				depths
							A  				=				num_heads
							A  				=				window_size
							A  				=				mlp_ratio
							A  				=				qkv_bias
							A  				=				hidden_dropout_prob
							A  				=				attention_probs_dropout_prob
							A  				=				drop_path_rate
							A  				=				hidden_act
							A  				=				use_absolute_embeddings
							A  				=				patch_norm
							A  				=				layer_norm_eps
							A  				=				initializer_range
							A  				=				is_training
							A  				=				scope
							A  				=				use_labels
							A  				=				type_sequence_label_size
							A  				=				encoder_stride


						def   _SCREAMING_SNAKE_CASE (	self       : Tuple )       ->				Any:
							A  				=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

							A  				=				None
							if self.use_labels:
								A  				=				ids_tensor([self.batch_size]					,self.type_sequence_label_size )

							A  				=				self.get_config()

							return config, pixel_values, labels


						def   _SCREAMING_SNAKE_CASE (	self       : Dict )       ->				List[str]:
							return DonutSwinConfig(
							    image_size=self.image_size					,patch_size=self.patch_size					,num_channels=self.num_channels					,embed_dim=self.embed_dim					,depths=self.depths					,num_heads=self.num_heads					,window_size=self.window_size					,mlp_ratio=self.mlp_ratio					,qkv_bias=self.qkv_bias					,hidden_dropout_prob=self.hidden_dropout_prob					,attention_probs_dropout_prob=self.attention_probs_dropout_prob					,drop_path_rate=self.drop_path_rate					,hidden_act=self.hidden_act					,use_absolute_embeddings=self.use_absolute_embeddings					,path_norm=self.patch_norm					,layer_norm_eps=self.layer_norm_eps					,initializer_range=self.initializer_range					,encoder_stride=self.encoder_stride					,)


						def   _SCREAMING_SNAKE_CASE (	self       : Optional[Any]					,A_       : str					,A_       : Dict					,A_       : Optional[Any] )       ->				Optional[Any]:
							A  				=				DonutSwinModel(config=A_ )
							model.to(A_ )
							model.eval()
							A  				=				model(A_ )

							A  				=				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
							A  				=				int(config.embed_dim * 2 ** (len(config.depths ) - 1) )

							self.parent.assertEqual(result.last_hidden_state.shape					,(self.batch_size, expected_seq_len, expected_dim) )




						def   _SCREAMING_SNAKE_CASE (	self       : str )       ->				str:
							A  				=				self.prepare_config_and_inputs()
							(
							    (
							    A
							)				, (
							    A
							)				, (
							    A
							)				, 
							)  				=				config_and_inputs
							A  				=				{'pixel_values': pixel_values}
							return config, inputs_dict







@require_torch
class 			lowerCAmelCase_			( _lowercase						,   _lowercase						,   unittest.TestCase      ):



						'''simple docstring'''


						_lowerCamelCase:      Tuple =      (DonutSwinModel,) if is_torch_available() else ()
						_lowerCamelCase:      Optional[int] =      {'''feature-extraction''': DonutSwinModel} if is_torch_available() else {}
						_lowerCamelCase:      Optional[Any] =      True

						_lowerCamelCase:      Union[str, Any] =      False
						_lowerCamelCase:      Optional[int] =      False
						_lowerCamelCase:      str =      False


						def   _SCREAMING_SNAKE_CASE (	self       : int )       ->				List[str]:
							A  				=				DonutSwinModelTester(self )
							A  				=				ConfigTester(self					,config_class=A_					,embed_dim=37 )


						def   _SCREAMING_SNAKE_CASE (	self       : List[str] )       ->				Optional[Any]:
							self.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.create_and_test_config_with_num_labels()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()


						def   _SCREAMING_SNAKE_CASE (	self       : str )       ->				List[str]:
							return


						def   _SCREAMING_SNAKE_CASE (	self       : Optional[Any] )       ->				List[str]:
							A  				=				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*A_ )


						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				Optional[Any]:
							# DonutSwin does not use inputs_embeds
							pass


						def   _SCREAMING_SNAKE_CASE (	self       : Union[str, Any] )       ->				Optional[int]:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								A  				=				model_class(A_ )
								self.assertIsInstance(model.get_input_embeddings()					,(nn.Module) )
								A  				=				model.get_output_embeddings()
								self.assertTrue(x is None or isinstance(A_					,nn.Linear ) )


						def   _SCREAMING_SNAKE_CASE (	self       : Union[str, Any] )       ->				str:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								A  				=				model_class(A_ )
								A  				=				inspect.signature(model.forward )
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								A  				=				[*signature.parameters.keys()]

								A  				=				['pixel_values']
								self.assertListEqual(arg_names[:1]					,A_ )


						def   _SCREAMING_SNAKE_CASE (	self       : List[str] )       ->				List[Any]:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()
							A  				=				True

							for model_class in self.all_model_classes:
								A  				=				True
								A  				=				False
								A  				=				True
								A  				=				model_class(A_ )
								model.to(A_ )
								model.eval()
								with torch.no_grad():
									A  				=				model(**self._prepare_for_class(A_					,A_ ) )
								A  				=				outputs.attentions
								A  				=				len(self.model_tester.depths )
								self.assertEqual(len(A_ )					,A_ )

								# check that output_attentions also work using config
								del inputs_dict["output_attentions"]
								A  				=				True
								A  				=				config.window_size**2
								A  				=				model_class(A_ )
								model.to(A_ )
								model.eval()
								with torch.no_grad():
									A  				=				model(**self._prepare_for_class(A_					,A_ ) )
								A  				=				outputs.attentions
								self.assertEqual(len(A_ )					,A_ )

								self.assertListEqual(
								    list(attentions[0].shape[-3:] )					,[self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,)
								A  				=				len(A_ )

								# Check attention is always last and order is fine
								A  				=				True
								A  				=				True
								A  				=				model_class(A_ )
								model.to(A_ )
								model.eval()
								with torch.no_grad():
									A  				=				model(**self._prepare_for_class(A_					,A_ ) )

								if hasattr(self.model_tester					,'num_hidden_states_types' ):
									A  				=				self.model_tester.num_hidden_states_types
								else:
									# also another +1 for reshaped_hidden_states
									A  				=				2
								self.assertEqual(out_len + added_hidden_states					,len(A_ ) )

								A  				=				outputs.attentions

								self.assertEqual(len(A_ )					,A_ )

								self.assertListEqual(
								    list(self_attentions[0].shape[-3:] )					,[self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,)


						def   _SCREAMING_SNAKE_CASE (	self       : Optional[int]					,A_       : Dict					,A_       : List[Any]					,A_       : Dict					,A_       : int )       ->				Tuple:
							A  				=				model_class(A_ )
							model.to(A_ )
							model.eval()

							with torch.no_grad():
								A  				=				model(**self._prepare_for_class(A_					,A_ ) )

							A  				=				outputs.hidden_states

							A  				=				getattr(
							    self.model_tester					,'expected_num_hidden_layers'					,len(self.model_tester.depths ) + 1 )
							self.assertEqual(len(A_ )					,A_ )

							# DonutSwin has a different seq_length
							A  				=				(
							    config.patch_size
							    if isinstance(config.patch_size					,collections.abc.Iterable )
							    else (config.patch_size, config.patch_size)
							)

							A  				=				(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

							self.assertListEqual(
							    list(hidden_states[0].shape[-2:] )					,[num_patches, self.model_tester.embed_dim]					,)

							A  				=				outputs.reshaped_hidden_states
							self.assertEqual(len(A_ )					,A_ )

							A				, A				, A				, A  				=				reshaped_hidden_states[0].shape
							A  				=				(
							    reshaped_hidden_states[0].view(A_					,A_					,height * width ).permute(0					,2					,1 )
							)
							self.assertListEqual(
							    list(reshaped_hidden_states.shape[-2:] )					,[num_patches, self.model_tester.embed_dim]					,)


						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				Optional[Any]:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

							A  				=				(
							    self.model_tester.image_size
							    if isinstance(self.model_tester.image_size					,collections.abc.Iterable )
							    else (self.model_tester.image_size, self.model_tester.image_size)
							)

							for model_class in self.all_model_classes:
								A  				=				True
								self.check_hidden_states_output(A_					,A_					,A_					,A_ )

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								A  				=				True

								self.check_hidden_states_output(A_					,A_					,A_					,A_ )


						def   _SCREAMING_SNAKE_CASE (	self       : str )       ->				Optional[int]:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()
							A  				=				3

							A  				=				(
							    self.model_tester.image_size
							    if isinstance(self.model_tester.image_size					,collections.abc.Iterable )
							    else (self.model_tester.image_size, self.model_tester.image_size)
							)
							A  				=				(
							    config.patch_size
							    if isinstance(config.patch_size					,collections.abc.Iterable )
							    else (config.patch_size, config.patch_size)
							)

							A  				=				image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							A  				=				image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
								A  				=				True
								self.check_hidden_states_output(A_					,A_					,A_					,(padded_height, padded_width) )

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								A  				=				True
								self.check_hidden_states_output(A_					,A_					,A_					,(padded_height, padded_width) )


						@slow
						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				Tuple:
							for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								A  				=				DonutSwinModel.from_pretrained(A_ )
								self.assertIsNotNone(A_ )




						def   _SCREAMING_SNAKE_CASE (	self       : Any )       ->				Any:
							A				, A  				=				self.model_tester.prepare_config_and_inputs_for_common()

							A  				=				_config_zero_init(A_ )
							for model_class in self.all_model_classes:
								A  				=				model_class(config=A_ )
								for name, param in model.named_parameters():
									if "embeddings" not in name and param.requires_grad:
										self.assertIn(
										    ((param.data.mean() * 1e9).round() / 1e9).item()					,[0.0, 1.0]					,msg=F'Parameter {name} of model {model_class} seems not properly initialized'					,)

"""simple docstring"""


from typing import TYPE_CHECKING

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


_lowercase											=			{
    '''auto_factory''': ['''get_values'''],
    '''configuration_auto''': ['''ALL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CONFIG_MAPPING''', '''MODEL_NAMES_MAPPING''', '''AutoConfig'''],
    '''feature_extraction_auto''': ['''FEATURE_EXTRACTOR_MAPPING''', '''AutoFeatureExtractor'''],
    '''image_processing_auto''': ['''IMAGE_PROCESSOR_MAPPING''', '''AutoImageProcessor'''],
    '''processing_auto''': ['''PROCESSOR_MAPPING''', '''AutoProcessor'''],
    '''tokenization_auto''': ['''TOKENIZER_MAPPING''', '''AutoTokenizer'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase											=			[
		    '''MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
		    '''MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING''',
		    '''MODEL_FOR_AUDIO_XVECTOR_MAPPING''',
		    '''MODEL_FOR_BACKBONE_MAPPING''',
		    '''MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING''',
		    '''MODEL_FOR_CAUSAL_LM_MAPPING''',
		    '''MODEL_FOR_CTC_MAPPING''',
		    '''MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING''',
		    '''MODEL_FOR_DEPTH_ESTIMATION_MAPPING''',
		    '''MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
		    '''MODEL_FOR_IMAGE_SEGMENTATION_MAPPING''',
		    '''MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING''',
		    '''MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING''',
		    '''MODEL_FOR_MASKED_LM_MAPPING''',
		    '''MODEL_FOR_MASK_GENERATION_MAPPING''',
		    '''MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
		    '''MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
		    '''MODEL_FOR_OBJECT_DETECTION_MAPPING''',
		    '''MODEL_FOR_PRETRAINING_MAPPING''',
		    '''MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
		    '''MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING''',
		    '''MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
		    '''MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
		    '''MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
		    '''MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING''',
		    '''MODEL_FOR_TEXT_ENCODING_MAPPING''',
		    '''MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
		    '''MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING''',
		    '''MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING''',
		    '''MODEL_FOR_VISION_2_SEQ_MAPPING''',
		    '''MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING''',
		    '''MODEL_MAPPING''',
		    '''MODEL_WITH_LM_HEAD_MAPPING''',
		    '''MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING''',
		    '''MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING''',
		    '''AutoModel''',
		    '''AutoBackbone''',
		    '''AutoModelForAudioClassification''',
		    '''AutoModelForAudioFrameClassification''',
		    '''AutoModelForAudioXVector''',
		    '''AutoModelForCausalLM''',
		    '''AutoModelForCTC''',
		    '''AutoModelForDepthEstimation''',
		    '''AutoModelForImageClassification''',
		    '''AutoModelForImageSegmentation''',
		    '''AutoModelForInstanceSegmentation''',
		    '''AutoModelForMaskGeneration''',
		    '''AutoModelForTextEncoding''',
		    '''AutoModelForMaskedImageModeling''',
		    '''AutoModelForMaskedLM''',
		    '''AutoModelForMultipleChoice''',
		    '''AutoModelForNextSentencePrediction''',
		    '''AutoModelForObjectDetection''',
		    '''AutoModelForPreTraining''',
		    '''AutoModelForQuestionAnswering''',
		    '''AutoModelForSemanticSegmentation''',
		    '''AutoModelForSeq2SeqLM''',
		    '''AutoModelForSequenceClassification''',
		    '''AutoModelForSpeechSeq2Seq''',
		    '''AutoModelForTableQuestionAnswering''',
		    '''AutoModelForTokenClassification''',
		    '''AutoModelForUniversalSegmentation''',
		    '''AutoModelForVideoClassification''',
		    '''AutoModelForVision2Seq''',
		    '''AutoModelForVisualQuestionAnswering''',
		    '''AutoModelForDocumentQuestionAnswering''',
		    '''AutoModelWithLMHead''',
		    '''AutoModelForZeroShotImageClassification''',
		    '''AutoModelForZeroShotObjectDetection''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase											=			[
		    '''TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
		    '''TF_MODEL_FOR_CAUSAL_LM_MAPPING''',
		    '''TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
		    '''TF_MODEL_FOR_MASK_GENERATION_MAPPING''',
		    '''TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING''',
		    '''TF_MODEL_FOR_MASKED_LM_MAPPING''',
		    '''TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
		    '''TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
		    '''TF_MODEL_FOR_PRETRAINING_MAPPING''',
		    '''TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
		    '''TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING''',
		    '''TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING''',
		    '''TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
		    '''TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
		    '''TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
		    '''TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING''',
		    '''TF_MODEL_FOR_TEXT_ENCODING_MAPPING''',
		    '''TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
		    '''TF_MODEL_FOR_VISION_2_SEQ_MAPPING''',
		    '''TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING''',
		    '''TF_MODEL_MAPPING''',
		    '''TF_MODEL_WITH_LM_HEAD_MAPPING''',
		    '''TFAutoModel''',
		    '''TFAutoModelForAudioClassification''',
		    '''TFAutoModelForCausalLM''',
		    '''TFAutoModelForImageClassification''',
		    '''TFAutoModelForMaskedImageModeling''',
		    '''TFAutoModelForMaskedLM''',
		    '''TFAutoModelForMaskGeneration''',
		    '''TFAutoModelForMultipleChoice''',
		    '''TFAutoModelForNextSentencePrediction''',
		    '''TFAutoModelForPreTraining''',
		    '''TFAutoModelForDocumentQuestionAnswering''',
		    '''TFAutoModelForQuestionAnswering''',
		    '''TFAutoModelForSemanticSegmentation''',
		    '''TFAutoModelForSeq2SeqLM''',
		    '''TFAutoModelForSequenceClassification''',
		    '''TFAutoModelForSpeechSeq2Seq''',
		    '''TFAutoModelForTableQuestionAnswering''',
		    '''TFAutoModelForTextEncoding''',
		    '''TFAutoModelForTokenClassification''',
		    '''TFAutoModelForVision2Seq''',
		    '''TFAutoModelForZeroShotImageClassification''',
		    '''TFAutoModelWithLMHead''',
		]

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase											=			[
		    '''FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
		    '''FLAX_MODEL_FOR_CAUSAL_LM_MAPPING''',
		    '''FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
		    '''FLAX_MODEL_FOR_MASKED_LM_MAPPING''',
		    '''FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
		    '''FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
		    '''FLAX_MODEL_FOR_PRETRAINING_MAPPING''',
		    '''FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
		    '''FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
		    '''FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
		    '''FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
		    '''FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
		    '''FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING''',
		    '''FLAX_MODEL_MAPPING''',
		    '''FlaxAutoModel''',
		    '''FlaxAutoModelForCausalLM''',
		    '''FlaxAutoModelForImageClassification''',
		    '''FlaxAutoModelForMaskedLM''',
		    '''FlaxAutoModelForMultipleChoice''',
		    '''FlaxAutoModelForNextSentencePrediction''',
		    '''FlaxAutoModelForPreTraining''',
		    '''FlaxAutoModelForQuestionAnswering''',
		    '''FlaxAutoModelForSeq2SeqLM''',
		    '''FlaxAutoModelForSequenceClassification''',
		    '''FlaxAutoModelForSpeechSeq2Seq''',
		    '''FlaxAutoModelForTokenClassification''',
		    '''FlaxAutoModelForVision2Seq''',
		]


if TYPE_CHECKING:
		from .auto_factory import get_values
		from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
		from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
		from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
		from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
		from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_auto import (
				    MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
				    MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
				    MODEL_FOR_AUDIO_XVECTOR_MAPPING,
				    MODEL_FOR_BACKBONE_MAPPING,
				    MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
				    MODEL_FOR_CAUSAL_LM_MAPPING,
				    MODEL_FOR_CTC_MAPPING,
				    MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
				    MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
				    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
				    MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
				    MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
				    MODEL_FOR_MASK_GENERATION_MAPPING,
				    MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
				    MODEL_FOR_MASKED_LM_MAPPING,
				    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
				    MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
				    MODEL_FOR_OBJECT_DETECTION_MAPPING,
				    MODEL_FOR_PRETRAINING_MAPPING,
				    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
				    MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
				    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
				    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
				    MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
				    MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
				    MODEL_FOR_TEXT_ENCODING_MAPPING,
				    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
				    MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
				    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
				    MODEL_FOR_VISION_2_SEQ_MAPPING,
				    MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
				    MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
				    MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
				    MODEL_MAPPING,
				    MODEL_WITH_LM_HEAD_MAPPING,
				    AutoBackbone,
				    AutoModel,
				    AutoModelForAudioClassification,
				    AutoModelForAudioFrameClassification,
				    AutoModelForAudioXVector,
				    AutoModelForCausalLM,
				    AutoModelForCTC,
				    AutoModelForDepthEstimation,
				    AutoModelForDocumentQuestionAnswering,
				    AutoModelForImageClassification,
				    AutoModelForImageSegmentation,
				    AutoModelForInstanceSegmentation,
				    AutoModelForMaskedImageModeling,
				    AutoModelForMaskedLM,
				    AutoModelForMaskGeneration,
				    AutoModelForMultipleChoice,
				    AutoModelForNextSentencePrediction,
				    AutoModelForObjectDetection,
				    AutoModelForPreTraining,
				    AutoModelForQuestionAnswering,
				    AutoModelForSemanticSegmentation,
				    AutoModelForSeqaSeqLM,
				    AutoModelForSequenceClassification,
				    AutoModelForSpeechSeqaSeq,
				    AutoModelForTableQuestionAnswering,
				    AutoModelForTextEncoding,
				    AutoModelForTokenClassification,
				    AutoModelForUniversalSegmentation,
				    AutoModelForVideoClassification,
				    AutoModelForVisionaSeq,
				    AutoModelForVisualQuestionAnswering,
				    AutoModelForZeroShotImageClassification,
				    AutoModelForZeroShotObjectDetection,
				    AutoModelWithLMHead,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_auto import (
				    TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
				    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
				    TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
				    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
				    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
				    TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
				    TF_MODEL_FOR_MASKED_LM_MAPPING,
				    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
				    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
				    TF_MODEL_FOR_PRETRAINING_MAPPING,
				    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
				    TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
				    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
				    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
				    TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
				    TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
				    TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
				    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
				    TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
				    TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
				    TF_MODEL_MAPPING,
				    TF_MODEL_WITH_LM_HEAD_MAPPING,
				    TFAutoModel,
				    TFAutoModelForAudioClassification,
				    TFAutoModelForCausalLM,
				    TFAutoModelForDocumentQuestionAnswering,
				    TFAutoModelForImageClassification,
				    TFAutoModelForMaskedImageModeling,
				    TFAutoModelForMaskedLM,
				    TFAutoModelForMaskGeneration,
				    TFAutoModelForMultipleChoice,
				    TFAutoModelForNextSentencePrediction,
				    TFAutoModelForPreTraining,
				    TFAutoModelForQuestionAnswering,
				    TFAutoModelForSemanticSegmentation,
				    TFAutoModelForSeqaSeqLM,
				    TFAutoModelForSequenceClassification,
				    TFAutoModelForSpeechSeqaSeq,
				    TFAutoModelForTableQuestionAnswering,
				    TFAutoModelForTextEncoding,
				    TFAutoModelForTokenClassification,
				    TFAutoModelForVisionaSeq,
				    TFAutoModelForZeroShotImageClassification,
				    TFAutoModelWithLMHead,
				)

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_auto import (
				    FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
				    FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
				    FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
				    FLAX_MODEL_FOR_MASKED_LM_MAPPING,
				    FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
				    FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
				    FLAX_MODEL_FOR_PRETRAINING_MAPPING,
				    FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
				    FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
				    FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
				    FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
				    FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
				    FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
				    FLAX_MODEL_MAPPING,
				    FlaxAutoModel,
				    FlaxAutoModelForCausalLM,
				    FlaxAutoModelForImageClassification,
				    FlaxAutoModelForMaskedLM,
				    FlaxAutoModelForMultipleChoice,
				    FlaxAutoModelForNextSentencePrediction,
				    FlaxAutoModelForPreTraining,
				    FlaxAutoModelForQuestionAnswering,
				    FlaxAutoModelForSeqaSeqLM,
				    FlaxAutoModelForSequenceClassification,
				    FlaxAutoModelForSpeechSeqaSeq,
				    FlaxAutoModelForTokenClassification,
				    FlaxAutoModelForVisionaSeq,
				)

else:
		import sys

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