


import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...utils import CONFIG_NAME, FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


lowerCamelCase						=		logging.get_logger(__name__)

lowerCamelCase						=		OrderedDict(
    [
        ('''audio-spectrogram-transformer''', '''ASTFeatureExtractor'''),
        ('''beit''', '''BeitFeatureExtractor'''),
        ('''chinese_clip''', '''ChineseCLIPFeatureExtractor'''),
        ('''clap''', '''ClapFeatureExtractor'''),
        ('''clip''', '''CLIPFeatureExtractor'''),
        ('''clipseg''', '''ViTFeatureExtractor'''),
        ('''conditional_detr''', '''ConditionalDetrFeatureExtractor'''),
        ('''convnext''', '''ConvNextFeatureExtractor'''),
        ('''cvt''', '''ConvNextFeatureExtractor'''),
        ('''data2vec-audio''', '''Wav2Vec2FeatureExtractor'''),
        ('''data2vec-vision''', '''BeitFeatureExtractor'''),
        ('''deformable_detr''', '''DeformableDetrFeatureExtractor'''),
        ('''deit''', '''DeiTFeatureExtractor'''),
        ('''detr''', '''DetrFeatureExtractor'''),
        ('''dinat''', '''ViTFeatureExtractor'''),
        ('''donut-swin''', '''DonutFeatureExtractor'''),
        ('''dpt''', '''DPTFeatureExtractor'''),
        ('''encodec''', '''EncodecFeatureExtractor'''),
        ('''flava''', '''FlavaFeatureExtractor'''),
        ('''glpn''', '''GLPNFeatureExtractor'''),
        ('''groupvit''', '''CLIPFeatureExtractor'''),
        ('''hubert''', '''Wav2Vec2FeatureExtractor'''),
        ('''imagegpt''', '''ImageGPTFeatureExtractor'''),
        ('''layoutlmv2''', '''LayoutLMv2FeatureExtractor'''),
        ('''layoutlmv3''', '''LayoutLMv3FeatureExtractor'''),
        ('''levit''', '''LevitFeatureExtractor'''),
        ('''maskformer''', '''MaskFormerFeatureExtractor'''),
        ('''mctct''', '''MCTCTFeatureExtractor'''),
        ('''mobilenet_v1''', '''MobileNetV1FeatureExtractor'''),
        ('''mobilenet_v2''', '''MobileNetV2FeatureExtractor'''),
        ('''mobilevit''', '''MobileViTFeatureExtractor'''),
        ('''nat''', '''ViTFeatureExtractor'''),
        ('''owlvit''', '''OwlViTFeatureExtractor'''),
        ('''perceiver''', '''PerceiverFeatureExtractor'''),
        ('''poolformer''', '''PoolFormerFeatureExtractor'''),
        ('''regnet''', '''ConvNextFeatureExtractor'''),
        ('''resnet''', '''ConvNextFeatureExtractor'''),
        ('''segformer''', '''SegformerFeatureExtractor'''),
        ('''sew''', '''Wav2Vec2FeatureExtractor'''),
        ('''sew-d''', '''Wav2Vec2FeatureExtractor'''),
        ('''speech_to_text''', '''Speech2TextFeatureExtractor'''),
        ('''speecht5''', '''SpeechT5FeatureExtractor'''),
        ('''swiftformer''', '''ViTFeatureExtractor'''),
        ('''swin''', '''ViTFeatureExtractor'''),
        ('''swinv2''', '''ViTFeatureExtractor'''),
        ('''table-transformer''', '''DetrFeatureExtractor'''),
        ('''timesformer''', '''VideoMAEFeatureExtractor'''),
        ('''tvlt''', '''TvltFeatureExtractor'''),
        ('''unispeech''', '''Wav2Vec2FeatureExtractor'''),
        ('''unispeech-sat''', '''Wav2Vec2FeatureExtractor'''),
        ('''van''', '''ConvNextFeatureExtractor'''),
        ('''videomae''', '''VideoMAEFeatureExtractor'''),
        ('''vilt''', '''ViltFeatureExtractor'''),
        ('''vit''', '''ViTFeatureExtractor'''),
        ('''vit_mae''', '''ViTFeatureExtractor'''),
        ('''vit_msn''', '''ViTFeatureExtractor'''),
        ('''wav2vec2''', '''Wav2Vec2FeatureExtractor'''),
        ('''wav2vec2-conformer''', '''Wav2Vec2FeatureExtractor'''),
        ('''wavlm''', '''Wav2Vec2FeatureExtractor'''),
        ('''whisper''', '''WhisperFeatureExtractor'''),
        ('''xclip''', '''CLIPFeatureExtractor'''),
        ('''yolos''', '''YolosFeatureExtractor'''),
    ]
)

lowerCamelCase						=		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)






def 					lowerCamelCase_   (	_a	):




		"""simple docstring"""






		for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
				if class_name in extractors:
						lowerCAmelCase__       :      Dict   					= model_type_to_module_name(_a	)

						lowerCAmelCase__       :      Optional[int]   					= importlib.import_module(f'.{module_name}'     ,       '''transformers.models'''	)
						try:
								return getattr(_a     ,       _a	)
						except AttributeError:
								continue

		for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
				if getattr(_a     ,       '''__name__'''     ,       _a	) == class_name:
						return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
		lowerCAmelCase__       :      Dict   					= importlib.import_module('''transformers'''	)
		if hasattr(_a     ,       _a	):
				return getattr(_a     ,       _a	)

		return None






def 					lowerCamelCase_   (	_a     ,       _a = None     ,       _a = False     ,       _a = False     ,       _a = None     ,       _a = None     ,       _a = None     ,       _a = False     ,       **_a     ,       ):




		"""simple docstring"""






		lowerCAmelCase__       :      Any   					= get_file_from_repo(
		    _a     ,       _a     ,       cache_dir=_a     ,       force_download=_a     ,       resume_download=_a     ,       proxies=_a     ,       use_auth_token=_a     ,       revision=_a     ,       local_files_only=_a     ,       )
		if resolved_config_file is None:
				logger.info(
				    '''Could not locate the feature extractor configuration file, will try to use the model config instead.'''	)
				return {}

		with open(_a     ,       encoding='''utf-8'''	) as reader:
				return json.load(_a	)





class  _a							:




	def __init__( self						:		Union[str, Any]		)->	List[Any]:
			raise EnvironmentError(
			    '''AutoFeatureExtractor is designed to be instantiated '''
			    '''using the `AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)` method.'''		)




	@classmethod
	@replace_list_option_in_docstrings(_SCREAMING_SNAKE_CASE		)
	def 							UpperCAmelCase__( cls						:		Any		, _SCREAMING_SNAKE_CASE						:		Optional[int]		, **_SCREAMING_SNAKE_CASE						:		Any		)->	Optional[int]:
			lowerCAmelCase__       :      Optional[Any]   					= kwargs.pop('''config'''		, _SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Dict   					= kwargs.pop('''trust_remote_code'''		, _SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      str   					= True

			lowerCAmelCase__					,     lowerCAmelCase__       :      int   					= FeatureExtractionMixin.get_feature_extractor_dict(_SCREAMING_SNAKE_CASE		, **_SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      List[str]   					= config_dict.get('''feature_extractor_type'''		, _SCREAMING_SNAKE_CASE		)
			lowerCAmelCase__       :      Optional[Any]   					= None
			if "AutoFeatureExtractor" in config_dict.get('''auto_map'''		, {}		):
					lowerCAmelCase__       :      List[Any]   					= config_dict['''auto_map''']['''AutoFeatureExtractor''']

			# If we don't find the feature extractor class in the feature extractor config, let's try the model config.
			if feature_extractor_class is None and feature_extractor_auto_map is None:
					if not isinstance(_SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		):
							lowerCAmelCase__       :      List[str]   					= AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		, **_SCREAMING_SNAKE_CASE		)
					# It could be in `config.feature_extractor_type``
					lowerCAmelCase__       :      Tuple   					= getattr(_SCREAMING_SNAKE_CASE		, '''feature_extractor_type'''		, _SCREAMING_SNAKE_CASE		)
					if hasattr(_SCREAMING_SNAKE_CASE		, '''auto_map'''		) and "AutoFeatureExtractor" in config.auto_map:
							lowerCAmelCase__       :      Any   					= config.auto_map['''AutoFeatureExtractor''']

			if feature_extractor_class is not None:
					lowerCAmelCase__       :      Optional[int]   					= feature_extractor_class_from_name(_SCREAMING_SNAKE_CASE		)

			lowerCAmelCase__       :      Dict   					= feature_extractor_auto_map is not None
			lowerCAmelCase__       :      Optional[int]   					= feature_extractor_class is not None or type(_SCREAMING_SNAKE_CASE		) in FEATURE_EXTRACTOR_MAPPING
			lowerCAmelCase__       :      Tuple   					= resolve_trust_remote_code(
			    _SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		)

			if has_remote_code and trust_remote_code:
					lowerCAmelCase__       :      int   					= get_class_from_dynamic_module(
					    _SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		, **_SCREAMING_SNAKE_CASE		)
					lowerCAmelCase__       :      int   					= kwargs.pop('''code_revision'''		, _SCREAMING_SNAKE_CASE		)
					if os.path.isdir(_SCREAMING_SNAKE_CASE		):
							feature_extractor_class.register_for_auto_class()
					return feature_extractor_class.from_dict(_SCREAMING_SNAKE_CASE		, **_SCREAMING_SNAKE_CASE		)
			elif feature_extractor_class is not None:
					return feature_extractor_class.from_dict(_SCREAMING_SNAKE_CASE		, **_SCREAMING_SNAKE_CASE		)
			# Last try: we use the FEATURE_EXTRACTOR_MAPPING.
			elif type(_SCREAMING_SNAKE_CASE		) in FEATURE_EXTRACTOR_MAPPING:
					lowerCAmelCase__       :      Dict   					= FEATURE_EXTRACTOR_MAPPING[type(_SCREAMING_SNAKE_CASE		)]
					return feature_extractor_class.from_dict(_SCREAMING_SNAKE_CASE		, **_SCREAMING_SNAKE_CASE		)

			raise ValueError(
			    F'Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a '
			    F'`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following '
			    F'`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys()		)}'		)




	@staticmethod
	def 							UpperCAmelCase__( _SCREAMING_SNAKE_CASE						:		str		, _SCREAMING_SNAKE_CASE						:		Optional[Any]		)->	Optional[int]:
			FEATURE_EXTRACTOR_MAPPING.register(_SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		)








from collections import OrderedDict

from ...utils import logging
from .auto_factory import _BaseAutoModelClass, _LazyAutoMapping, auto_class_update
from .configuration_auto import CONFIG_MAPPING_NAMES


lowerCamelCase						=		logging.get_logger(__name__)


lowerCamelCase						=		OrderedDict(
    [
        # Base model mapping
        ('''albert''', '''FlaxAlbertModel'''),
        ('''bart''', '''FlaxBartModel'''),
        ('''beit''', '''FlaxBeitModel'''),
        ('''bert''', '''FlaxBertModel'''),
        ('''big_bird''', '''FlaxBigBirdModel'''),
        ('''blenderbot''', '''FlaxBlenderbotModel'''),
        ('''blenderbot-small''', '''FlaxBlenderbotSmallModel'''),
        ('''clip''', '''FlaxCLIPModel'''),
        ('''distilbert''', '''FlaxDistilBertModel'''),
        ('''electra''', '''FlaxElectraModel'''),
        ('''gpt-sw3''', '''FlaxGPT2Model'''),
        ('''gpt2''', '''FlaxGPT2Model'''),
        ('''gpt_neo''', '''FlaxGPTNeoModel'''),
        ('''gptj''', '''FlaxGPTJModel'''),
        ('''longt5''', '''FlaxLongT5Model'''),
        ('''marian''', '''FlaxMarianModel'''),
        ('''mbart''', '''FlaxMBartModel'''),
        ('''mt5''', '''FlaxMT5Model'''),
        ('''opt''', '''FlaxOPTModel'''),
        ('''pegasus''', '''FlaxPegasusModel'''),
        ('''regnet''', '''FlaxRegNetModel'''),
        ('''resnet''', '''FlaxResNetModel'''),
        ('''roberta''', '''FlaxRobertaModel'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormModel'''),
        ('''roformer''', '''FlaxRoFormerModel'''),
        ('''t5''', '''FlaxT5Model'''),
        ('''vision-text-dual-encoder''', '''FlaxVisionTextDualEncoderModel'''),
        ('''vit''', '''FlaxViTModel'''),
        ('''wav2vec2''', '''FlaxWav2Vec2Model'''),
        ('''whisper''', '''FlaxWhisperModel'''),
        ('''xglm''', '''FlaxXGLMModel'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaModel'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for pre-training mapping
        ('''albert''', '''FlaxAlbertForPreTraining'''),
        ('''bart''', '''FlaxBartForConditionalGeneration'''),
        ('''bert''', '''FlaxBertForPreTraining'''),
        ('''big_bird''', '''FlaxBigBirdForPreTraining'''),
        ('''electra''', '''FlaxElectraForPreTraining'''),
        ('''longt5''', '''FlaxLongT5ForConditionalGeneration'''),
        ('''mbart''', '''FlaxMBartForConditionalGeneration'''),
        ('''mt5''', '''FlaxMT5ForConditionalGeneration'''),
        ('''roberta''', '''FlaxRobertaForMaskedLM'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForMaskedLM'''),
        ('''roformer''', '''FlaxRoFormerForMaskedLM'''),
        ('''t5''', '''FlaxT5ForConditionalGeneration'''),
        ('''wav2vec2''', '''FlaxWav2Vec2ForPreTraining'''),
        ('''whisper''', '''FlaxWhisperForConditionalGeneration'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaForMaskedLM'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Masked LM mapping
        ('''albert''', '''FlaxAlbertForMaskedLM'''),
        ('''bart''', '''FlaxBartForConditionalGeneration'''),
        ('''bert''', '''FlaxBertForMaskedLM'''),
        ('''big_bird''', '''FlaxBigBirdForMaskedLM'''),
        ('''distilbert''', '''FlaxDistilBertForMaskedLM'''),
        ('''electra''', '''FlaxElectraForMaskedLM'''),
        ('''mbart''', '''FlaxMBartForConditionalGeneration'''),
        ('''roberta''', '''FlaxRobertaForMaskedLM'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForMaskedLM'''),
        ('''roformer''', '''FlaxRoFormerForMaskedLM'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaForMaskedLM'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Seq2Seq Causal LM mapping
        ('''bart''', '''FlaxBartForConditionalGeneration'''),
        ('''blenderbot''', '''FlaxBlenderbotForConditionalGeneration'''),
        ('''blenderbot-small''', '''FlaxBlenderbotSmallForConditionalGeneration'''),
        ('''encoder-decoder''', '''FlaxEncoderDecoderModel'''),
        ('''longt5''', '''FlaxLongT5ForConditionalGeneration'''),
        ('''marian''', '''FlaxMarianMTModel'''),
        ('''mbart''', '''FlaxMBartForConditionalGeneration'''),
        ('''mt5''', '''FlaxMT5ForConditionalGeneration'''),
        ('''pegasus''', '''FlaxPegasusForConditionalGeneration'''),
        ('''t5''', '''FlaxT5ForConditionalGeneration'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Image-classsification
        ('''beit''', '''FlaxBeitForImageClassification'''),
        ('''regnet''', '''FlaxRegNetForImageClassification'''),
        ('''resnet''', '''FlaxResNetForImageClassification'''),
        ('''vit''', '''FlaxViTForImageClassification'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        ('''vision-encoder-decoder''', '''FlaxVisionEncoderDecoderModel'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Causal LM mapping
        ('''bart''', '''FlaxBartForCausalLM'''),
        ('''bert''', '''FlaxBertForCausalLM'''),
        ('''big_bird''', '''FlaxBigBirdForCausalLM'''),
        ('''electra''', '''FlaxElectraForCausalLM'''),
        ('''gpt-sw3''', '''FlaxGPT2LMHeadModel'''),
        ('''gpt2''', '''FlaxGPT2LMHeadModel'''),
        ('''gpt_neo''', '''FlaxGPTNeoForCausalLM'''),
        ('''gptj''', '''FlaxGPTJForCausalLM'''),
        ('''opt''', '''FlaxOPTForCausalLM'''),
        ('''roberta''', '''FlaxRobertaForCausalLM'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForCausalLM'''),
        ('''xglm''', '''FlaxXGLMForCausalLM'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaForCausalLM'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Sequence Classification mapping
        ('''albert''', '''FlaxAlbertForSequenceClassification'''),
        ('''bart''', '''FlaxBartForSequenceClassification'''),
        ('''bert''', '''FlaxBertForSequenceClassification'''),
        ('''big_bird''', '''FlaxBigBirdForSequenceClassification'''),
        ('''distilbert''', '''FlaxDistilBertForSequenceClassification'''),
        ('''electra''', '''FlaxElectraForSequenceClassification'''),
        ('''mbart''', '''FlaxMBartForSequenceClassification'''),
        ('''roberta''', '''FlaxRobertaForSequenceClassification'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForSequenceClassification'''),
        ('''roformer''', '''FlaxRoFormerForSequenceClassification'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaForSequenceClassification'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Question Answering mapping
        ('''albert''', '''FlaxAlbertForQuestionAnswering'''),
        ('''bart''', '''FlaxBartForQuestionAnswering'''),
        ('''bert''', '''FlaxBertForQuestionAnswering'''),
        ('''big_bird''', '''FlaxBigBirdForQuestionAnswering'''),
        ('''distilbert''', '''FlaxDistilBertForQuestionAnswering'''),
        ('''electra''', '''FlaxElectraForQuestionAnswering'''),
        ('''mbart''', '''FlaxMBartForQuestionAnswering'''),
        ('''roberta''', '''FlaxRobertaForQuestionAnswering'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForQuestionAnswering'''),
        ('''roformer''', '''FlaxRoFormerForQuestionAnswering'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaForQuestionAnswering'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Token Classification mapping
        ('''albert''', '''FlaxAlbertForTokenClassification'''),
        ('''bert''', '''FlaxBertForTokenClassification'''),
        ('''big_bird''', '''FlaxBigBirdForTokenClassification'''),
        ('''distilbert''', '''FlaxDistilBertForTokenClassification'''),
        ('''electra''', '''FlaxElectraForTokenClassification'''),
        ('''roberta''', '''FlaxRobertaForTokenClassification'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForTokenClassification'''),
        ('''roformer''', '''FlaxRoFormerForTokenClassification'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaForTokenClassification'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        # Model for Multiple Choice mapping
        ('''albert''', '''FlaxAlbertForMultipleChoice'''),
        ('''bert''', '''FlaxBertForMultipleChoice'''),
        ('''big_bird''', '''FlaxBigBirdForMultipleChoice'''),
        ('''distilbert''', '''FlaxDistilBertForMultipleChoice'''),
        ('''electra''', '''FlaxElectraForMultipleChoice'''),
        ('''roberta''', '''FlaxRobertaForMultipleChoice'''),
        ('''roberta-prelayernorm''', '''FlaxRobertaPreLayerNormForMultipleChoice'''),
        ('''roformer''', '''FlaxRoFormerForMultipleChoice'''),
        ('''xlm-roberta''', '''FlaxXLMRobertaForMultipleChoice'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        ('''bert''', '''FlaxBertForNextSentencePrediction'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        ('''speech-encoder-decoder''', '''FlaxSpeechEncoderDecoderModel'''),
        ('''whisper''', '''FlaxWhisperForConditionalGeneration'''),
    ]
)

lowerCamelCase						=		OrderedDict(
    [
        ('''whisper''', '''FlaxWhisperForAudioClassification'''),
    ]
)

lowerCamelCase						=		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_MAPPING_NAMES)
lowerCamelCase						=		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_PRETRAINING_MAPPING_NAMES)
lowerCamelCase						=		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MASKED_LM_MAPPING_NAMES)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING_NAMES)
lowerCamelCase						=		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_CAUSAL_LM_MAPPING_NAMES)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES
)
lowerCamelCase						=		_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES
)





class  _a							(    _BaseAutoModelClass):
	_a  :  List[str]				   =							FLAX_MODEL_MAPPING
lowerCamelCase						=		auto_class_update(FlaxAutoModel)





class  _a							(    _BaseAutoModelClass):
	_a  :  Union[str, Any]				   =							FLAX_MODEL_FOR_PRETRAINING_MAPPING
lowerCamelCase						=		auto_class_update(FlaxAutoModelForPreTraining, head_doc='''pretraining''')





class  _a							(    _BaseAutoModelClass):
	_a  :  Optional[Any]				   =							FLAX_MODEL_FOR_CAUSAL_LM_MAPPING
lowerCamelCase						=		auto_class_update(FlaxAutoModelForCausalLM, head_doc='''causal language modeling''')





class  _a							(    _BaseAutoModelClass):
	_a  :  Tuple				   =							FLAX_MODEL_FOR_MASKED_LM_MAPPING
lowerCamelCase						=		auto_class_update(FlaxAutoModelForMaskedLM, head_doc='''masked language modeling''')





class  _a							(    _BaseAutoModelClass):
	_a  :  Dict				   =							FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
lowerCamelCase						=		auto_class_update(
    FlaxAutoModelForSeqaSeqLM, head_doc='''sequence-to-sequence language modeling''', checkpoint_for_example='''t5-base'''
)





class  _a							(    _BaseAutoModelClass):
	_a  :  Union[str, Any]				   =							FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
lowerCamelCase						=		auto_class_update(
    FlaxAutoModelForSequenceClassification, head_doc='''sequence classification'''
)





class  _a							(    _BaseAutoModelClass):
	_a  :  str				   =							FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING
lowerCamelCase						=		auto_class_update(FlaxAutoModelForQuestionAnswering, head_doc='''question answering''')





class  _a							(    _BaseAutoModelClass):
	_a  :  Union[str, Any]				   =							FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING
lowerCamelCase						=		auto_class_update(
    FlaxAutoModelForTokenClassification, head_doc='''token classification'''
)





class  _a							(    _BaseAutoModelClass):
	_a  :  List[Any]				   =							FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING
lowerCamelCase						=		auto_class_update(FlaxAutoModelForMultipleChoice, head_doc='''multiple choice''')





class  _a							(    _BaseAutoModelClass):
	_a  :  Any				   =							FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING
lowerCamelCase						=		auto_class_update(
    FlaxAutoModelForNextSentencePrediction, head_doc='''next sentence prediction'''
)





class  _a							(    _BaseAutoModelClass):
	_a  :  List[Any]				   =							FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
lowerCamelCase						=		auto_class_update(
    FlaxAutoModelForImageClassification, head_doc='''image classification'''
)





class  _a							(    _BaseAutoModelClass):
	_a  :  List[Any]				   =							FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING
lowerCamelCase						=		auto_class_update(FlaxAutoModelForVisionaSeq, head_doc='''vision-to-text modeling''')





class  _a							(    _BaseAutoModelClass):
	_a  :  Optional[Any]				   =							FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING
lowerCamelCase						=		auto_class_update(
    FlaxAutoModelForSpeechSeqaSeq, head_doc='''sequence-to-sequence speech-to-text modeling'''
)




