





"""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			      =	logging.get_logger(__name__)

A			      =	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			      =	_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)

def      __A   (      a_    :Tuple)		->		Tuple:



				for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
								if class_name in extractors:
												__a			:    Tuple      							=	model_type_to_module_name(a__)

												__a			:    Any      							=	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.
				__a			:    Tuple      							=	importlib.import_module('''transformers''')
				if hasattr(a__ ,							a__):
								return getattr(a__ ,							a__)

				return None

def      __A   (      a_    :Optional[int] ,							a_    :List[str] = None ,							a_    :List[Any] = False ,							a_    :List[str] = False ,							a_    :Optional[int] = None ,							a_    :Union[str, Any] = None ,							a_    :Optional[Any] = None ,							a_    :Optional[int] = False ,							**a_    :Any ,							)		->		Dict:
				__a			:    List[str]      							=	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 					__lowercase      :







					'''simple docstring'''




					def __init__(    self  ):
									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(_lowercase  )
					def 			_lowerCamelCase		(    cls						,      _UpperCAmelCase						,      **_UpperCAmelCase  ):
									__a			:    Tuple      							=	kwargs.pop('''config'''						,      _lowercase  )
									__a			:    Dict      							=	kwargs.pop('''trust_remote_code'''						,      _lowercase  )
									__a			:    Dict      							=	True

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

									if feature_extractor_class is not None:
													__a			:    int      							=	feature_extractor_class_from_name(_lowercase  )

									__a			:    Dict      							=	feature_extractor_auto_map is not None
									__a			:    Union[str, Any]      							=	feature_extractor_class is not None or type(_lowercase  ) in FEATURE_EXTRACTOR_MAPPING
									__a			:    Optional[Any]      							=	resolve_trust_remote_code(
									    _lowercase						,      _lowercase						,      _lowercase						,      _lowercase  )

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

									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						,      _UpperCAmelCase  ):
									FEATURE_EXTRACTOR_MAPPING.register(_lowercase						,      _lowercase  )


__snake_case				:      int   		=			[
    """Audio""",
    """Array2D""",
    """Array3D""",
    """Array4D""",
    """Array5D""",
    """ClassLabel""",
    """Features""",
    """Sequence""",
    """Value""",
    """Image""",
    """Translation""",
    """TranslationVariableLanguages""",
]
from .audio import Audio
from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value
from .image import Image
from .translation import Translation, TranslationVariableLanguages


