

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        lowerCamelCase__       (    _a):
	for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
		if class_name in extractors:
			SCREAMING_SNAKE_CASE      :					Optional[int]    =				model_type_to_module_name(_a)

			SCREAMING_SNAKE_CASE      :					Optional[Any]    =				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[Any]    =				importlib.import_module("transformers")
	if hasattr(_a							,	_a):
		return getattr(_a							,	_a)

	return None

def        lowerCamelCase__       (    _a							,	_a = None							,	_a = False							,	_a = False							,	_a = None							,	_a = None							,	_a = None							,	_a = False							,	**_a							,	):
	SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				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							:
			'''simple docstring'''







			def __init__(	self							:       Union[str, Any]		)							->				Optional[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(a		)
			def 							__UpperCamelCase       (	cls							:       Union[str, Any]					,					a							:       List[Any]					,					**a							:       Dict		)							->				Optional[int]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					List[str]    =				kwargs.pop("config"					,					a		)
				SCREAMING_SNAKE_CASE      :					Optional[int]    =				kwargs.pop("trust_remote_code"					,					a		)
				SCREAMING_SNAKE_CASE      :					List[Any]    =				True

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

				if feature_extractor_class is not None:
					SCREAMING_SNAKE_CASE      :					Optional[Any]    =				feature_extractor_class_from_name(a		)

				SCREAMING_SNAKE_CASE      :					List[Any]    =				feature_extractor_auto_map is not None
				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				feature_extractor_class is not None or type(a		) in FEATURE_EXTRACTOR_MAPPING
				SCREAMING_SNAKE_CASE      :					Any    =				resolve_trust_remote_code(
				    a					,					a					,					a					,					a		)

				if has_remote_code and trust_remote_code:
					SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				get_class_from_dynamic_module(
					    a					,					a					,					**a		)
					SCREAMING_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:
					SCREAMING_SNAKE_CASE      :					Tuple    =				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 							__UpperCamelCase       (	a							:       List[str]					,					a							:       Optional[int]		)							->				Any:

				"""simple docstring"""

				FEATURE_EXTRACTOR_MAPPING.register(a					,					a		)






import re
from pathlib import Path
from unittest import TestCase

import pytest






@pytest.mark.integration
class     lowercase__       (	__lowerCamelCase				):

   '''simple docstring'''


   def       UpperCamelCase__  (    self,		__magic_name__							) ->      Union[str, Any]:






       """simple docstring"""

       with open(__magic_name__,		encoding='''utf-8'''							) as input_file:
           UpperCamelCase__							:				Tuple          =      re.compile(R'''(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)'''							)
           UpperCamelCase__							:				str          =      input_file.read()
           UpperCamelCase__							:				List[Any]          =      regexp.search(__magic_name__							)

       return match




   def       UpperCamelCase__  (    self,		__magic_name__							) ->      Any:






       """simple docstring"""

       with open(__magic_name__,		encoding='''utf-8'''							) as input_file:
           UpperCamelCase__							:				Dict          =      re.compile(R'''#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()''',		re.DOTALL							)
           UpperCamelCase__							:				Any          =      input_file.read()
           # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search`
           UpperCamelCase__							:				Tuple          =      regexp.finditer(__magic_name__							)

       UpperCamelCase__							:				Dict          =      [match for match in matches if match is not None and match.group(1							) is not None]
       return matches[0] if matches else None




   def       UpperCamelCase__  (    self							) ->      List[Any]:






       """simple docstring"""
       UpperCamelCase__							:				int          =      Path('''./datasets'''							)
       UpperCamelCase__							:				Any          =      list(dataset_paths.absolute().glob('''**/*.py'''							)							)

       for dataset in dataset_files:
           if self._no_encoding_on_file_open(str(__magic_name__							)							):
               raise AssertionError(f"open(...) must use utf-8 encoding in {dataset}"							)




   def       UpperCamelCase__  (    self							) ->      Dict:






       """simple docstring"""
       UpperCamelCase__							:				Optional[int]          =      Path('''./datasets'''							)
       UpperCamelCase__							:				Optional[Any]          =      list(dataset_paths.absolute().glob('''**/*.py'''							)							)

       for dataset in dataset_files:
           if self._no_print_statements(str(__magic_name__							)							):
               raise AssertionError(f"print statement found in {dataset}. Use datasets.logger/logging instead."							)

