



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


UpperCamelCase__:     Optional[Any]										=    logging.get_logger(__name__)

UpperCamelCase__:     int										=    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"),
    ]
)

UpperCamelCase__:     Optional[int]										=    _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)


def 				snake_case_  (      _lowerCAmelCase						:		str						)   ->     Tuple:
							for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
														if class_name in extractors:
																					UpperCAmelCase				: Optional[Any]											=	model_type_to_module_name(_lowerCAmelCase						)

																					UpperCAmelCase				: List[str]											=	importlib.import_module(f""".{module_name}"""     ,   '''transformers.models'''						)
																					try:
																												return getattr(_lowerCAmelCase     ,   _lowerCAmelCase						)
																					except AttributeError:
																												continue

							for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
														if getattr(_lowerCAmelCase     ,   '''__name__'''     ,   _lowerCAmelCase						) == 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.
							UpperCAmelCase				: str											=	importlib.import_module('''transformers'''						)
							if hasattr(_lowerCAmelCase     ,   _lowerCAmelCase						):
														return getattr(_lowerCAmelCase     ,   _lowerCAmelCase						)

							return None


def 				snake_case_  (      _lowerCAmelCase						:		Union[str, os.PathLike]     ,   _lowerCAmelCase						:		Optional[Union[str, os.PathLike]] = None     ,   _lowerCAmelCase						:		bool = False     ,   _lowerCAmelCase						:		bool = False     ,   _lowerCAmelCase						:		Optional[Dict[str, str]] = None     ,   _lowerCAmelCase						:		Optional[Union[bool, str]] = None     ,   _lowerCAmelCase						:		Optional[str] = None     ,   _lowerCAmelCase						:		bool = False     ,   **_lowerCAmelCase						:		Any     ,   )   ->     List[str]:
							UpperCAmelCase				: Optional[int]											=	get_file_from_repo(
							    _lowerCAmelCase     ,   _lowerCAmelCase     ,   cache_dir=_lowerCAmelCase     ,   force_download=_lowerCAmelCase     ,   resume_download=_lowerCAmelCase     ,   proxies=_lowerCAmelCase     ,   use_auth_token=_lowerCAmelCase     ,   revision=_lowerCAmelCase     ,   local_files_only=_lowerCAmelCase     ,   )
							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(_lowerCAmelCase     ,   encoding='''utf-8'''						) as reader:
														return json.load(_lowerCAmelCase						)




class        SCREAMING_SNAKE_CASE:







	"""simple docstring"""






	def __init__(		self    :  str	)    ->	str:
								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(__snake_case	)
	def   A			(		cls    :  List[Any]	,    __snake_case    :  Optional[Any]	,    **__snake_case    :  Union[str, Any]	)    ->	Optional[int]:
								UpperCAmelCase				: Optional[Any]											=	kwargs.pop('''config'''	,    __snake_case	)
								UpperCAmelCase				: Any											=	kwargs.pop('''trust_remote_code'''	,    __snake_case	)
								UpperCAmelCase				: List[Any]											=	True

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

								if feature_extractor_class is not None:
															UpperCAmelCase				: Optional[Any]											=	feature_extractor_class_from_name(__snake_case	)

								UpperCAmelCase				: Tuple											=	feature_extractor_auto_map is not None
								UpperCAmelCase				: str											=	feature_extractor_class is not None or type(__snake_case	) in FEATURE_EXTRACTOR_MAPPING
								UpperCAmelCase				: str											=	resolve_trust_remote_code(
								    __snake_case	,    __snake_case	,    __snake_case	,    __snake_case	)

								if has_remote_code and trust_remote_code:
															UpperCAmelCase				: int											=	get_class_from_dynamic_module(
															    __snake_case	,    __snake_case	,    **__snake_case	)
															UpperCAmelCase				: Optional[int]											=	kwargs.pop('''code_revision'''	,    __snake_case	)
															if os.path.isdir(__snake_case	):
																						feature_extractor_class.register_for_auto_class()
															return feature_extractor_class.from_dict(__snake_case	,    **__snake_case	)
								elif feature_extractor_class is not None:
															return feature_extractor_class.from_dict(__snake_case	,    **__snake_case	)
								# Last try: we use the FEATURE_EXTRACTOR_MAPPING.
								elif type(__snake_case	) in FEATURE_EXTRACTOR_MAPPING:
															UpperCAmelCase				: Union[str, Any]											=	FEATURE_EXTRACTOR_MAPPING[type(__snake_case	)]
															return feature_extractor_class.from_dict(__snake_case	,    **__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   A			(		__snake_case    :  Optional[int]	,    __snake_case    :  List[Any]	)    ->	Dict:
								FEATURE_EXTRACTOR_MAPPING.register(__snake_case	,    __snake_case	)










'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCamelCase__:     Union[str, Any]										=    {
    "configuration_lilt": ["LILT_PRETRAINED_CONFIG_ARCHIVE_MAP", "LiltConfig"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						UpperCamelCase__:     List[str]										=    [
						    "LILT_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "LiltForQuestionAnswering",
						    "LiltForSequenceClassification",
						    "LiltForTokenClassification",
						    "LiltModel",
						    "LiltPreTrainedModel",
						]

if TYPE_CHECKING:
						from .configuration_lilt import LILT_PRETRAINED_CONFIG_ARCHIVE_MAP, LiltConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_lilt import (
												    LILT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    LiltForQuestionAnswering,
												    LiltForSequenceClassification,
												    LiltForTokenClassification,
												    LiltModel,
												    LiltPreTrainedModel,
												)

else:
						import sys

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





