

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,
)


SCREAMING_SNAKE_CASE_        =      logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_        =      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'),
    ]
)

SCREAMING_SNAKE_CASE_        =      _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  str )   ->       Any:
				for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
								if class_name in extractors:
												_UpperCAmelCase       :		Union[str, Any] 		=    model_type_to_module_name(lowerCAmelCase )

												_UpperCAmelCase       :		List[str] 		=    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.
				_UpperCAmelCase       :		Union[str, Any] 		=    importlib.import_module("transformers" )
				if hasattr(lowerCAmelCase  ,      lowerCAmelCase ):
								return getattr(lowerCAmelCase  ,      lowerCAmelCase )

				return None

def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  Union[str, os.PathLike]  ,      lowerCAmelCase:  Optional[Union[str, os.PathLike]] = None  ,      lowerCAmelCase:  bool = False  ,      lowerCAmelCase:  bool = False  ,      lowerCAmelCase:  Optional[Dict[str, str]] = None  ,      lowerCAmelCase:  Optional[Union[bool, str]] = None  ,      lowerCAmelCase:  Optional[str] = None  ,      lowerCAmelCase:  bool = False  ,      **lowerCAmelCase:  Optional[Any]  ,      )   ->       Dict:
				_UpperCAmelCase       :		Any 		=    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 				a  :


						def __init__(       self	):







										'''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						,					A_						,					**A_	):







										'''simple docstring'''


										_UpperCAmelCase       :		int 		=    kwargs.pop("config"						,					A_	)
										_UpperCAmelCase       :		Dict 		=    kwargs.pop("trust_remote_code"						,					A_	)
										_UpperCAmelCase       :		Any 		=    True

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

										if feature_extractor_class is not None:
														_UpperCAmelCase       :		str 		=    feature_extractor_class_from_name(A_	)

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

										if has_remote_code and trust_remote_code:
														_UpperCAmelCase       :		Tuple 		=    get_class_from_dynamic_module(
														    A_						,					A_						,					**A_	)
														_UpperCAmelCase       :		Optional[Any] 		=    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:
														_UpperCAmelCase       :		Union[str, 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        _UpperCAmelCase				(       A_						,					A_	):







										'''simple docstring'''


										FEATURE_EXTRACTOR_MAPPING.register(A_						,					A_	)





import logging
import os

from .state import PartialState

class 				a  (	logging.LoggerAdapter				):


						@staticmethod
						def        _UpperCAmelCase				(       A_	):







										'''simple docstring'''


										_UpperCAmelCase       :		Tuple 		=    PartialState()
										return not main_process_only or (main_process_only and state.is_main_process)





						def        _UpperCAmelCase				(       self						,					A_						,					A_						,					*A_						,					**A_	):







										'''simple docstring'''


										if PartialState._shared_state == {}:
														raise RuntimeError(
														    "You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility."	)
										_UpperCAmelCase       :		Tuple 		=    kwargs.pop("main_process_only"						,					A_	)
										_UpperCAmelCase       :		int 		=    kwargs.pop("in_order"						,					A_	)

										if self.isEnabledFor(A_	):
														if self._should_log(A_	):
																		_UpperCAmelCase		,							_UpperCAmelCase       :		Optional[int] 		=    self.process(A_						,					A_	)
																		self.logger.log(A_						,					A_						,					*A_						,					**A_	)

														elif in_order:
																		_UpperCAmelCase       :		Dict 		=    PartialState()
																		for i in range(state.num_processes	):
																						if i == state.process_index:
																										_UpperCAmelCase		,							_UpperCAmelCase       :		Union[str, Any] 		=    self.process(A_						,					A_	)
																										self.logger.log(A_						,					A_						,					*A_						,					**A_	)
																						state.wait_for_everyone()







def 							__SCREAMING_SNAKE_CASE							(				lowerCAmelCase:  str  ,      lowerCAmelCase:  str = None )   ->       List[Any]:
				if log_level is None:
								_UpperCAmelCase       :		List[str] 		=    os.environ.get("ACCELERATE_LOG_LEVEL"  ,      lowerCAmelCase )
				_UpperCAmelCase       :		str 		=    logging.getLogger(lowerCAmelCase )
				if log_level is not None:
								logger.setLevel(log_level.upper() )
								logger.root.setLevel(log_level.upper() )
				return MultiProcessAdapter(lowerCAmelCase  ,      {} )


