
"""simple docstring"""





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_					:						str				= 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 							A_     (__a				):

     '''simple docstring'''





     for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
          if class_name in extractors:
               A_				 =						model_type_to_module_name(__a				)

               A_				 =						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.
     A_				 =						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				,   ):

     '''simple docstring'''





     A_				 =						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 __lowerCAmelCase				:




   """simple docstring"""







   def __init__(				self						:					List[Any]	)      -> Tuple:







        """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(_snake_case	)
   def      lowerCamelCase__     (				cls						:					Optional[int]       ,   _snake_case						:					List[Any]       ,   **_snake_case						:					List[Any]	)      -> str:







        """simple docstring"""
        A_				 =						kwargs.pop("config"       ,   _snake_case	)
        A_				 =						kwargs.pop("trust_remote_code"       ,   _snake_case	)
        A_				 =						True

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

        if feature_extractor_class is not None:
             A_				 =						feature_extractor_class_from_name(_snake_case	)

        A_				 =						feature_extractor_auto_map is not None
        A_				 =						feature_extractor_class is not None or type(_snake_case	) in FEATURE_EXTRACTOR_MAPPING
        A_				 =						resolve_trust_remote_code(
            _snake_case       ,   _snake_case       ,   _snake_case       ,   _snake_case	)

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

        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__     (				_snake_case						:					Optional[int]       ,   _snake_case						:					Optional[int]	)      -> Optional[int]:







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






"""simple docstring"""





from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


UpperCamelCase_					:						Optional[int]				= logging.get_logger(__name__)

UpperCamelCase_					:						Dict				= {
    '''microsoft/focalnet-tiny''': '''https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json''',
}



class __lowerCAmelCase				(					_lowercase     ,				_lowercase      ):




			"""simple docstring"""







			snake_case	      =				"focalnet"




			def __init__(				self						:					Any       ,   _snake_case						:					Optional[int]=224       ,   _snake_case						:					List[str]=4       ,   _snake_case						:					Any=3       ,   _snake_case						:					List[Any]=96       ,   _snake_case						:					Union[str, Any]=False       ,   _snake_case						:					Optional[Any]=[192, 384, 768, 768]       ,   _snake_case						:					List[str]=[2, 2, 6, 2]       ,   _snake_case						:					Any=[2, 2, 2, 2]       ,   _snake_case						:					List[Any]=[3, 3, 3, 3]       ,   _snake_case						:					Optional[Any]="gelu"       ,   _snake_case						:					Dict=4.0       ,   _snake_case						:					List[Any]=0.0       ,   _snake_case						:					List[str]=0.1       ,   _snake_case						:					Optional[Any]=False       ,   _snake_case						:					Any=1e-4       ,   _snake_case						:					str=False       ,   _snake_case						:					Optional[int]=False       ,   _snake_case						:					Tuple=False       ,   _snake_case						:					Any=0.0_2       ,   _snake_case						:					List[Any]=1e-5       ,   _snake_case						:					Union[str, Any]=32       ,   _snake_case						:					Tuple=None       ,   _snake_case						:					Any=None       ,   **_snake_case						:					Tuple       ,   )      -> str:







								"""simple docstring"""
								super().__init__(**_snake_case	)

								A_				 =						image_size
								A_				 =						patch_size
								A_				 =						num_channels
								A_				 =						embed_dim
								A_				 =						use_conv_embed
								A_				 =						hidden_sizes
								A_				 =						depths
								A_				 =						focal_levels
								A_				 =						focal_windows
								A_				 =						hidden_act
								A_				 =						mlp_ratio
								A_				 =						hidden_dropout_prob
								A_				 =						drop_path_rate
								A_				 =						use_layerscale
								A_				 =						layerscale_value
								A_				 =						use_post_layernorm
								A_				 =						use_post_layernorm_in_modulation
								A_				 =						normalize_modulator
								A_				 =						initializer_range
								A_				 =						layer_norm_eps
								A_				 =						encoder_stride
								A_				 =						["stem"] + [F'stage{idx}' for idx in range(1       ,   len(self.depths	) + 1	)]
								A_ ,    A_				 =						get_aligned_output_features_output_indices(
								    out_features=_snake_case       ,   out_indices=_snake_case       ,   stage_names=self.stage_names	)




