





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     :    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     :    Dict         =						_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)
def 							a_	(    __magic_name__   )				->			Dict:




				"""simple docstring"""






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

												snake_case   :					Any    						=				importlib.import_module(F".{module_name}"		,     '''transformers.models'''   )
												try:
																return getattr(__magic_name__		,     __magic_name__   )
												except AttributeError:
																continue

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

				return None
def 							a_	(    __magic_name__		,     __magic_name__ = None		,     __magic_name__ = False		,     __magic_name__ = False		,     __magic_name__ = None		,     __magic_name__ = None		,     __magic_name__ = None		,     __magic_name__ = False		,     **__magic_name__		,     )				->			Any:




				"""simple docstring"""






				snake_case   :					Dict    						=				get_file_from_repo(
				    __magic_name__		,     __magic_name__		,     cache_dir=__magic_name__		,     force_download=__magic_name__		,     resume_download=__magic_name__		,     proxies=__magic_name__		,     use_auth_token=__magic_name__		,     revision=__magic_name__		,     local_files_only=__magic_name__		,     )
				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(__magic_name__		,     encoding='''utf-8'''   ) as reader:
								return json.load(__magic_name__   )
class   a_ :

			def __init__(   self   :  Dict						):






							"""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(a_						)
			def      lowerCAmelCase(   cls   :  str     , UpperCAmelCase__   :  Union[str, Any]     , **UpperCAmelCase__   :  Optional[Any]						):






							"""simple docstring"""
							snake_case   :					str    						=				kwargs.pop('''config'''     , a_						)
							snake_case   :					str    						=				kwargs.pop('''trust_remote_code'''     , a_						)
							snake_case   :					Union[str, Any]    						=				True

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

							if feature_extractor_class is not None:
											snake_case   :					Tuple    						=				feature_extractor_class_from_name(a_						)

							snake_case   :					Any    						=				feature_extractor_auto_map is not None
							snake_case   :					int    						=				feature_extractor_class is not None or type(a_						) in FEATURE_EXTRACTOR_MAPPING
							snake_case   :					List[Any]    						=				resolve_trust_remote_code(
							    a_     , a_     , a_     , a_						)

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

							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__   :  Optional[Any]     , UpperCAmelCase__   :  Optional[Any]						):






							"""simple docstring"""
							FEATURE_EXTRACTOR_MAPPING.register(a_     , a_						)



'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_a					:			Dict							=    {
    'configuration_xlm': ['XLM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'XLMConfig', 'XLMOnnxConfig'],
    'tokenization_xlm': ['XLMTokenizer'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a					:			Optional[Any]							=    [
      'XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'XLMForMultipleChoice',
      'XLMForQuestionAnswering',
      'XLMForQuestionAnsweringSimple',
      'XLMForSequenceClassification',
      'XLMForTokenClassification',
      'XLMModel',
      'XLMPreTrainedModel',
      'XLMWithLMHeadModel',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a					:			int							=    [
      'TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFXLMForMultipleChoice',
      'TFXLMForQuestionAnsweringSimple',
      'TFXLMForSequenceClassification',
      'TFXLMForTokenClassification',
      'TFXLMMainLayer',
      'TFXLMModel',
      'TFXLMPreTrainedModel',
      'TFXLMWithLMHeadModel',
  ]


if TYPE_CHECKING:
  from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
  from .tokenization_xlm import XLMTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_xlm import (
        XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        XLMForMultipleChoice,
        XLMForQuestionAnswering,
        XLMForQuestionAnsweringSimple,
        XLMForSequenceClassification,
        XLMForTokenClassification,
        XLMModel,
        XLMPreTrainedModel,
        XLMWithLMHeadModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_xlm import (
        TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFXLMForMultipleChoice,
        TFXLMForQuestionAnsweringSimple,
        TFXLMForSequenceClassification,
        TFXLMForTokenClassification,
        TFXLMMainLayer,
        TFXLMModel,
        TFXLMPreTrainedModel,
        TFXLMWithLMHeadModel,
    )

else:
  import sys

  _a					:			Union[str, Any]							=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


