






'''simple docstring'''







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,
)


_A	:			Any         =logging.get_logger(__name__)

_A	:			List[str]         =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'''),
    ]
)

_A	:			Dict         =_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)





def  SCREAMING_SNAKE_CASE_       (UpperCamelCase      )      ->       str:
							for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
														if class_name in extractors:
																					lowerCamelCase__					:	List[Any]         =       model_type_to_module_name(UpperCamelCase      )

																					lowerCamelCase__					:	Any         =       importlib.import_module(f'''.{module_name}'''				,			"""transformers.models"""      )
																					try:
																												return getattr(UpperCamelCase				,			UpperCamelCase      )
																					except AttributeError:
																												continue

							for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
														if getattr(UpperCamelCase				,			"""__name__"""				,			UpperCamelCase      ) == 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__					:	List[Any]         =       importlib.import_module("""transformers"""      )
							if hasattr(UpperCamelCase				,			UpperCamelCase      ):
														return getattr(UpperCamelCase				,			UpperCamelCase      )

							return None





def  SCREAMING_SNAKE_CASE_       (UpperCamelCase				,			UpperCamelCase = None				,			UpperCamelCase = False				,			UpperCamelCase = False				,			UpperCamelCase = None				,			UpperCamelCase = None				,			UpperCamelCase = None				,			UpperCamelCase = False				,			**UpperCamelCase				,			)      ->       Optional[Any]:
							lowerCamelCase__					:	Optional[Any]         =       get_file_from_repo(
							    UpperCamelCase				,			UpperCamelCase				,			cache_dir=UpperCamelCase				,			force_download=UpperCamelCase				,			resume_download=UpperCamelCase				,			proxies=UpperCamelCase				,			use_auth_token=UpperCamelCase				,			revision=UpperCamelCase				,			local_files_only=UpperCamelCase				,			)
							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(UpperCamelCase				,			encoding="""utf-8"""      ) as reader:
														return json.load(UpperCamelCase      )



class _lowercase	:




							def __init__(							self:				Optional[int]     ):
														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(UpperCamelCase__     )
							def 		lowerCamelCase_				(							cls:				List[Any]			,							UpperCamelCase__:				int			,							**UpperCamelCase__:				str     ):
														lowerCamelCase__					:	List[Any]         =       kwargs.pop("""config"""			,							UpperCamelCase__     )
														lowerCamelCase__					:	int         =       kwargs.pop("""trust_remote_code"""			,							UpperCamelCase__     )
														lowerCamelCase__					:	Dict         =       True

														lowerCamelCase__  ,		lowerCamelCase__					:	Optional[Any]         =       FeatureExtractionMixin.get_feature_extractor_dict(UpperCamelCase__			,							**UpperCamelCase__     )
														lowerCamelCase__					:	List[str]         =       config_dict.get("""feature_extractor_type"""			,							UpperCamelCase__     )
														lowerCamelCase__					:	Tuple         =       None
														if "AutoFeatureExtractor" in config_dict.get("""auto_map"""			,							{}     ):
																					lowerCamelCase__					:	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(UpperCamelCase__			,							UpperCamelCase__     ):
																												lowerCamelCase__					:	List[str]         =       AutoConfig.from_pretrained(UpperCamelCase__			,							**UpperCamelCase__     )
																					# It could be in `config.feature_extractor_type``
																					lowerCamelCase__					:	Tuple         =       getattr(UpperCamelCase__			,							"""feature_extractor_type"""			,							UpperCamelCase__     )
																					if hasattr(UpperCamelCase__			,							"""auto_map"""     ) and "AutoFeatureExtractor" in config.auto_map:
																												lowerCamelCase__					:	Union[str, Any]         =       config.auto_map["""AutoFeatureExtractor"""]

														if feature_extractor_class is not None:
																					lowerCamelCase__					:	List[Any]         =       feature_extractor_class_from_name(UpperCamelCase__     )

														lowerCamelCase__					:	str         =       feature_extractor_auto_map is not None
														lowerCamelCase__					:	Optional[Any]         =       feature_extractor_class is not None or type(UpperCamelCase__     ) in FEATURE_EXTRACTOR_MAPPING
														lowerCamelCase__					:	Optional[Any]         =       resolve_trust_remote_code(
														    UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__     )

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

														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 		lowerCamelCase_				(							UpperCamelCase__:				Optional[Any]			,							UpperCamelCase__:				Optional[Any]     ):
														FEATURE_EXTRACTOR_MAPPING.register(UpperCamelCase__			,							UpperCamelCase__     )









"""simple docstring"""



from typing import TYPE_CHECKING

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


__A		:       List[Any]  				=		{
    '''configuration_mega''': ['''MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MegaConfig''', '''MegaOnnxConfig'''],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__A		:       List[str]  				=		[
						    '''MEGA_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''MegaForCausalLM''',
						    '''MegaForMaskedLM''',
						    '''MegaForMultipleChoice''',
						    '''MegaForQuestionAnswering''',
						    '''MegaForSequenceClassification''',
						    '''MegaForTokenClassification''',
						    '''MegaModel''',
						    '''MegaPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mega import (
												    MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
												    MegaForCausalLM,
												    MegaForMaskedLM,
												    MegaForMultipleChoice,
												    MegaForQuestionAnswering,
												    MegaForSequenceClassification,
												    MegaForTokenClassification,
												    MegaModel,
												    MegaPreTrainedModel,
												)

else:
						import sys

						__A		:       Any  				=		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



