

'''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 					_lowercase     (				a_				:					str				)				->	Tuple:




					'''simple docstring'''







					for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
										if class_name in extractors:
															__magic_name__							=    model_type_to_module_name(a_				)

															__magic_name__							=    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.
					__magic_name__							=    importlib.import_module('transformers'				)
					if hasattr(a_					,a_				):
										return getattr(a_					,a_				)

					return None




def 					_lowercase     (				a_				:					Union[str, os.PathLike]					,a_				:					Optional[Union[str, os.PathLike]] = None					,a_				:					bool = False					,a_				:					bool = False					,a_				:					Optional[Dict[str, str]] = None					,a_				:					Optional[Union[bool, str]] = None					,a_				:					Optional[str] = None					,a_				:					bool = False					,**a_				:					Tuple					,)				->	List[str]:




					'''simple docstring'''







					__magic_name__							=    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 				__UpperCamelCase				:







	def __init__(   self: int      ):

						'''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(__UpperCamelCase      )
	def 	_SCREAMING_SNAKE_CASE							(   cls: str  , __UpperCamelCase: int  , **__UpperCamelCase: List[str]      ):

						'''simple docstring'''





						__magic_name__							=    kwargs.pop('config'  , __UpperCamelCase      )
						__magic_name__							=    kwargs.pop('trust_remote_code'  , __UpperCamelCase      )
						__magic_name__							=    True

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

						if feature_extractor_class is not None:
											__magic_name__							=    feature_extractor_class_from_name(__UpperCamelCase      )

						__magic_name__							=    feature_extractor_auto_map is not None
						__magic_name__							=    feature_extractor_class is not None or type(__UpperCamelCase      ) in FEATURE_EXTRACTOR_MAPPING
						__magic_name__							=    resolve_trust_remote_code(
						    __UpperCamelCase  , __UpperCamelCase  , __UpperCamelCase  , __UpperCamelCase      )

						if has_remote_code and trust_remote_code:
											__magic_name__							=    get_class_from_dynamic_module(
											    __UpperCamelCase  , __UpperCamelCase  , **__UpperCamelCase      )
											__magic_name__							=    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:
											__magic_name__							=    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 	_SCREAMING_SNAKE_CASE							(   __UpperCamelCase: int  , __UpperCamelCase: Optional[Any]      ):

						'''simple docstring'''





						FEATURE_EXTRACTOR_MAPPING.register(__UpperCamelCase  , __UpperCamelCase      )







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A__						=							logging.get_logger(__name__)

A__						=							{
    "camembert-base": "https://huggingface.co/camembert-base/resolve/main/config.json",
    "umberto-commoncrawl-cased-v1": (
        "https://huggingface.co/Musixmatch/umberto-commoncrawl-cased-v1/resolve/main/config.json"
    ),
    "umberto-wikipedia-uncased-v1": (
        "https://huggingface.co/Musixmatch/umberto-wikipedia-uncased-v1/resolve/main/config.json"
    ),
}

class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE			):
	_lowercase  :   Optional[int]       				=  "camembert"







	def __init__(   self: Optional[Any]  , __UpperCamelCase: Any=3_05_22  , __UpperCamelCase: Tuple=7_68  , __UpperCamelCase: str=12  , __UpperCamelCase: Optional[int]=12  , __UpperCamelCase: List[str]=30_72  , __UpperCamelCase: Any="gelu"  , __UpperCamelCase: Optional[int]=0.1  , __UpperCamelCase: Any=0.1  , __UpperCamelCase: str=5_12  , __UpperCamelCase: Dict=2  , __UpperCamelCase: str=0.02  , __UpperCamelCase: List[Any]=1E-12  , __UpperCamelCase: List[Any]=1  , __UpperCamelCase: Any=0  , __UpperCamelCase: Union[str, Any]=2  , __UpperCamelCase: Dict="absolute"  , __UpperCamelCase: Any=True  , __UpperCamelCase: Any=None  , **__UpperCamelCase: Union[str, Any]  , ):

						'''simple docstring'''





						super().__init__(pad_token_id=__UpperCamelCase  , bos_token_id=__UpperCamelCase  , eos_token_id=__UpperCamelCase  , **__UpperCamelCase      )

						__magic_name__							=    vocab_size
						__magic_name__							=    hidden_size
						__magic_name__							=    num_hidden_layers
						__magic_name__							=    num_attention_heads
						__magic_name__							=    hidden_act
						__magic_name__							=    intermediate_size
						__magic_name__							=    hidden_dropout_prob
						__magic_name__							=    attention_probs_dropout_prob
						__magic_name__							=    max_position_embeddings
						__magic_name__							=    type_vocab_size
						__magic_name__							=    initializer_range
						__magic_name__							=    layer_norm_eps
						__magic_name__							=    position_embedding_type
						__magic_name__							=    use_cache
						__magic_name__							=    classifier_dropout




class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE			):







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						if self.task == "multiple-choice":
											__magic_name__							=    {0: 'batch', 1: 'choice', 2: 'sequence'}
						else:
											__magic_name__							=    {0: 'batch', 1: 'sequence'}
						return OrderedDict(
						    [
						        ('input_ids', dynamic_axis),
						        ('attention_mask', dynamic_axis),
						    ]      )




