


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_ :Union[str, Any]  							=			logging.get_logger(__name__)

a_ :Union[str, Any]  							=			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_ :int  							=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)




def    a   (							A__							)	-> Dict:




      '''simple docstring'''

      for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
            if class_name in extractors:
                  SCREAMING_SNAKE_CASE__       :  Union[str, Any]						     =		model_type_to_module_name(A__							)

                  SCREAMING_SNAKE_CASE__       :  str						     =		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.
      SCREAMING_SNAKE_CASE__       :  List[str]						     =		importlib.import_module('''transformers'''							)
      if hasattr(A__      ,    A__							):
            return getattr(A__      ,    A__							)

      return None




def    a   (							A__      ,    A__ = None      ,    A__ = False      ,    A__ = False      ,    A__ = None      ,    A__ = None      ,    A__ = None      ,    A__ = False      ,    **A__      ,    )	-> List[Any]:




      '''simple docstring'''

      SCREAMING_SNAKE_CASE__       :  int						     =		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  :







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

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

           if feature_extractor_class is not None:
                 SCREAMING_SNAKE_CASE__       :  Any						     =		feature_extractor_class_from_name(_lowercase      )

           SCREAMING_SNAKE_CASE__       :  List[Any]						     =		feature_extractor_auto_map is not None
           SCREAMING_SNAKE_CASE__       :  List[Any]						     =		feature_extractor_class is not None or type(_lowercase      ) in FEATURE_EXTRACTOR_MAPPING
           SCREAMING_SNAKE_CASE__       :  Dict						     =		resolve_trust_remote_code(
               _lowercase   ,   _lowercase   ,   _lowercase   ,   _lowercase      )

           if has_remote_code and trust_remote_code:
                 SCREAMING_SNAKE_CASE__       :  List[Any]						     =		get_class_from_dynamic_module(
                     _lowercase   ,   _lowercase   ,   **_lowercase      )
                 SCREAMING_SNAKE_CASE__       :  List[Any]						     =		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:
                 SCREAMING_SNAKE_CASE__       :  Tuple						     =		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 							lowercase__       (						_lowercase :						Dict   ,   _lowercase :						Optional[Any]      ):
           FEATURE_EXTRACTOR_MAPPING.register(_lowercase   ,   _lowercase      )







'''simple docstring'''

from collections import OrderedDict
from typing import Mapping

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


UpperCamelCase__  :						List[str]					=      logging.get_logger(__name__)

UpperCamelCase__  :						str					=      {
    '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 					_lowercase						(   lowerCAmelCase ):
      '''simple docstring'''


      UpperCAmelCase_   :   Dict   				= '''camembert'''




      def __init__(					self       ,lowerCamelCase_=30522       ,lowerCamelCase_=768       ,lowerCamelCase_=12       ,lowerCamelCase_=12       ,lowerCamelCase_=3072       ,lowerCamelCase_="gelu"       ,lowerCamelCase_=0.1       ,lowerCamelCase_=0.1       ,lowerCamelCase_=512       ,lowerCamelCase_=2       ,lowerCamelCase_=0.02       ,lowerCamelCase_=1e-12       ,lowerCamelCase_=1       ,lowerCamelCase_=0       ,lowerCamelCase_=2       ,lowerCamelCase_="absolute"       ,lowerCamelCase_=True       ,lowerCamelCase_=None       ,**lowerCamelCase_       ,)      ->      str:



         '''simple docstring'''



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

         UpperCAmelCase__				:					int 					=	vocab_size
         UpperCAmelCase__				:					List[Any] 					=	hidden_size
         UpperCAmelCase__				:					Tuple 					=	num_hidden_layers
         UpperCAmelCase__				:					List[str] 					=	num_attention_heads
         UpperCAmelCase__				:					int 					=	hidden_act
         UpperCAmelCase__				:					Tuple 					=	intermediate_size
         UpperCAmelCase__				:					List[Any] 					=	hidden_dropout_prob
         UpperCAmelCase__				:					Tuple 					=	attention_probs_dropout_prob
         UpperCAmelCase__				:					str 					=	max_position_embeddings
         UpperCAmelCase__				:					Union[str, Any] 					=	type_vocab_size
         UpperCAmelCase__				:					int 					=	initializer_range
         UpperCAmelCase__				:					Optional[Any] 					=	layer_norm_eps
         UpperCAmelCase__				:					Optional[Any] 					=	position_embedding_type
         UpperCAmelCase__				:					str 					=	use_cache
         UpperCAmelCase__				:					List[Any] 					=	classifier_dropout




class 					_lowercase						(   lowerCAmelCase ):
      '''simple docstring'''


      @property
      def 		lowerCAmelCase__       (					self				)      ->      Mapping[str, Mapping[int, str]]:



         '''simple docstring'''



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




