





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


_UpperCAmelCase       : Union[str, Any]			     =       logging.get_logger(__name__)

_UpperCAmelCase       : Optional[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"""),
    ]
)

_UpperCAmelCase       : int			     =       _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase				)    ->  Tuple:
    for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
        if class_name in extractors:
            lowerCamelCase__					:   Optional[Any]      				=	model_type_to_module_name(_UpperCAmelCase				)

            lowerCamelCase__					:   int      				=	importlib.import_module(F""".{module_name}"""		,			'transformers.models'				)
            try:
                return getattr(_UpperCAmelCase		,			_UpperCAmelCase				)
            except AttributeError:
                continue

    for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
        if getattr(_UpperCAmelCase		,			'__name__'		,			_UpperCAmelCase				) == 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.
    lowerCamelCase__					:   int      				=	importlib.import_module('transformers'				)
    if hasattr(_UpperCAmelCase		,			_UpperCAmelCase				):
        return getattr(_UpperCAmelCase		,			_UpperCAmelCase				)

    return None


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase = None		,			_UpperCAmelCase = False		,			_UpperCAmelCase = False		,			_UpperCAmelCase = None		,			_UpperCAmelCase = None		,			_UpperCAmelCase = None		,			_UpperCAmelCase = False		,			**_UpperCAmelCase		,			)    ->  Dict:
    lowerCamelCase__					:   Tuple      				=	get_file_from_repo(
        _UpperCAmelCase		,			_UpperCAmelCase		,			cache_dir=_UpperCAmelCase		,			force_download=_UpperCAmelCase		,			resume_download=_UpperCAmelCase		,			proxies=_UpperCAmelCase		,			use_auth_token=_UpperCAmelCase		,			revision=_UpperCAmelCase		,			local_files_only=_UpperCAmelCase		,			)
    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(_UpperCAmelCase		,			encoding='utf-8'				) as reader:
        return json.load(_UpperCAmelCase				)


class      lowerCAmelCase							:
 def __init__(   self						:   Optional[Any]			)    ->			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(UpperCAmelCase			)
 def   A_			(   cls						:   Optional[Any]    ,  UpperCAmelCase						:   str    ,  **UpperCAmelCase						:   Dict			)    ->			str:
     lowerCamelCase__					:   int      				=	kwargs.pop('config'    ,  UpperCAmelCase			)
     lowerCamelCase__					:   str      				=	kwargs.pop('trust_remote_code'    ,  UpperCAmelCase			)
     lowerCamelCase__					:   List[str]      				=	True

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

     if feature_extractor_class is not None:
         lowerCamelCase__					:   List[Any]      				=	feature_extractor_class_from_name(UpperCAmelCase			)

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

     if has_remote_code and trust_remote_code:
         lowerCamelCase__					:   Optional[int]      				=	get_class_from_dynamic_module(
             UpperCAmelCase    ,  UpperCAmelCase    ,  **UpperCAmelCase			)
         lowerCamelCase__					:   Union[str, Any]      				=	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:
         lowerCamelCase__					:   Tuple      				=	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   A_			(   UpperCAmelCase						:   List[str]    ,  UpperCAmelCase						:   Optional[int]			)    ->			List[str]:
     FEATURE_EXTRACTOR_MAPPING.register(UpperCAmelCase    ,  UpperCAmelCase			)












class      lowerCAmelCase							:
 def __init__(   self						:   Union[str, Any]    ,  UpperCAmelCase						:   list			)    ->			None:
     lowerCamelCase__					:   int      				=	set_counts
     lowerCamelCase__					:   List[str]      				=	max(UpperCAmelCase			)
     lowerCamelCase__					:   Dict      				=	len(UpperCAmelCase			)
     lowerCamelCase__					:   List[str]      				=	[1] * num_sets
     lowerCamelCase__					:   List[str]      				=	list(range(UpperCAmelCase			)			)
 def   A_			(   self						:   Dict    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   int			)    ->			bool:
     lowerCamelCase__					:   List[str]      				=	self.get_parent(UpperCAmelCase			)
     lowerCamelCase__					:   List[str]      				=	self.get_parent(UpperCAmelCase			)

     if src_parent == dst_parent:
         return False

     if self.ranks[dst_parent] >= self.ranks[src_parent]:
         self.set_counts[dst_parent] += self.set_counts[src_parent]
         lowerCamelCase__					:   Union[str, Any]      				=	0
         lowerCamelCase__					:   str      				=	dst_parent
         if self.ranks[dst_parent] == self.ranks[src_parent]:
             self.ranks[dst_parent] += 1
         lowerCamelCase__					:   int      				=	self.set_counts[dst_parent]
     else:
         self.set_counts[src_parent] += self.set_counts[dst_parent]
         lowerCamelCase__					:   List[str]      				=	0
         lowerCamelCase__					:   Tuple      				=	src_parent
         lowerCamelCase__					:   List[str]      				=	self.set_counts[src_parent]

     lowerCamelCase__					:   Optional[int]      				=	max(self.max_set    ,  UpperCAmelCase			)
     return True







 def   A_			(   self						:   str    ,  UpperCAmelCase						:   int			)    ->			int:
     if self.parents[disj_set] == disj_set:
         return disj_set
     lowerCamelCase__					:   Dict      				=	self.get_parent(self.parents[disj_set]			)
     return self.parents[disj_set]





