


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							:					List[Any]     						=     logging.get_logger(__name__)

A							:					Optional[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'),
    ]
)

A							:					Any     						=     _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)





def 	_lowerCAmelCase       (    _lowerCAmelCase )						->	List[str]:


						'''simple docstring'''






						for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
												if class_name in extractors:
																		__snake_case				=		model_type_to_module_name(_lowerCAmelCase )

																		__snake_case				=		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.
						__snake_case				=		importlib.import_module("transformers" )
						if hasattr(_lowerCAmelCase      ,	_lowerCAmelCase ):
												return getattr(_lowerCAmelCase      ,	_lowerCAmelCase )

						return None





def 	_lowerCAmelCase       (    _lowerCAmelCase      ,	_lowerCAmelCase = None      ,	_lowerCAmelCase = False      ,	_lowerCAmelCase = False      ,	_lowerCAmelCase = None      ,	_lowerCAmelCase = None      ,	_lowerCAmelCase = None      ,	_lowerCAmelCase = False      ,	**_lowerCAmelCase      ,	)						->	str:


						'''simple docstring'''






						__snake_case				=		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     UpperCamelCase:


					def __init__(						self	:		Tuple						)			->	Any:




											'''simple docstring'''

											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 							SCREAMING_SNAKE_CASE_  (						cls	:		List[Any]     ,    SCREAMING_SNAKE_CASE	:		Any     ,    **SCREAMING_SNAKE_CASE	:		Optional[Any]						)			->	int:




											'''simple docstring'''

											__snake_case				=		kwargs.pop("config"     ,    SCREAMING_SNAKE_CASE						)
											__snake_case				=		kwargs.pop("trust_remote_code"     ,    SCREAMING_SNAKE_CASE						)
											__snake_case				=		True

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

											if feature_extractor_class is not None:
																	__snake_case				=		feature_extractor_class_from_name(SCREAMING_SNAKE_CASE						)

											__snake_case				=		feature_extractor_auto_map is not None
											__snake_case				=		feature_extractor_class is not None or type(SCREAMING_SNAKE_CASE						) in FEATURE_EXTRACTOR_MAPPING
											__snake_case				=		resolve_trust_remote_code(
											    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE						)

											if has_remote_code and trust_remote_code:
																	__snake_case				=		get_class_from_dynamic_module(
																	    SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE     ,    **SCREAMING_SNAKE_CASE						)
																	__snake_case				=		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:
																	__snake_case				=		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 							SCREAMING_SNAKE_CASE_  (						SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]						)			->	int:




											'''simple docstring'''

											FEATURE_EXTRACTOR_MAPPING.register(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE						)









def 	_lowerCAmelCase       (    _lowerCAmelCase )						->	int:


						'''simple docstring'''






						__snake_case				=		abs(_lowerCAmelCase )
						__snake_case				=		0
						while n > 0:
												res += n % 10
												n //= 10
						return res





def 	_lowerCAmelCase       (    _lowerCAmelCase )						->	int:


						'''simple docstring'''






						__snake_case				=		abs(_lowerCAmelCase )
						return n if n < 10 else n % 10 + sum_of_digits(n // 10 )





def 	_lowerCAmelCase       (    _lowerCAmelCase )						->	int:


						'''simple docstring'''






						return sum(int(_lowerCAmelCase ) for c in str(abs(_lowerCAmelCase ) ) )





def 	_lowerCAmelCase       (    )						->	None:


						'''simple docstring'''






						from collections.abc import Callable
						from timeit import timeit

						def benchmark_a_function(_lowerCAmelCase      ,	_lowerCAmelCase ) -> None:
												__snake_case				=		F'''{func.__name__}({value})'''
												__snake_case				=		timeit(F'''__main__.{call}'''      ,	setup="import __main__" )
												print(F'''{call:56} = {func(_lowerCAmelCase )} -- {timing:.4f} seconds''' )

						for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
												for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact):
																		benchmark_a_function(_lowerCAmelCase      ,	_lowerCAmelCase )
												print()


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	benchmark()





