
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_		:     str        =     logging.get_logger(__name__)

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

A_		:     List[Any]        =     _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)


def 	UpperCAmelCase__      (      UpperCAmelCase__ :str					):






 '''simple docstring'''

 for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
  if class_name in extractors:
   a						=		model_type_to_module_name(UpperCAmelCase__					)

   a						=		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.
 a						=		importlib.import_module("transformers"					)
 if hasattr(UpperCAmelCase__ ,					UpperCAmelCase__					):
  return getattr(UpperCAmelCase__ ,					UpperCAmelCase__					)

 return None


def 	UpperCAmelCase__      (      UpperCAmelCase__ :Union[str, os.PathLike] ,					UpperCAmelCase__ :Optional[Union[str, os.PathLike]] = None ,					UpperCAmelCase__ :bool = False ,					UpperCAmelCase__ :bool = False ,					UpperCAmelCase__ :Optional[Dict[str, str]] = None ,					UpperCAmelCase__ :Optional[Union[bool, str]] = None ,					UpperCAmelCase__ :Optional[str] = None ,					UpperCAmelCase__ :bool = False ,					**UpperCAmelCase__ :List[str] ,					):






 '''simple docstring'''

 a						=		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 		_lowercase		:

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


    """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(__lowerCAmelCase							)
   def 		A							(      cls			:       List[str]							,   __lowerCAmelCase			:       Any							,   **__lowerCAmelCase			:       Union[str, Any]							)       ->				Union[str, Any]:


    """simple docstring"""






    a						=		kwargs.pop("config"							,   __lowerCAmelCase							)
    a						=		kwargs.pop("trust_remote_code"							,   __lowerCAmelCase							)
    a						=		True

    a		,  a						=		FeatureExtractionMixin.get_feature_extractor_dict(__lowerCAmelCase							,   **__lowerCAmelCase							)
    a						=		config_dict.get("feature_extractor_type"							,   __lowerCAmelCase							)
    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(__lowerCAmelCase							,   __lowerCAmelCase							):
      a						=		AutoConfig.from_pretrained(__lowerCAmelCase							,   **__lowerCAmelCase							)
     # It could be in `config.feature_extractor_type``
     a						=		getattr(__lowerCAmelCase							,   "feature_extractor_type"							,   __lowerCAmelCase							)
     if hasattr(__lowerCAmelCase							,   "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(__lowerCAmelCase							)

    a						=		feature_extractor_auto_map is not None
    a						=		feature_extractor_class is not None or type(__lowerCAmelCase							) in FEATURE_EXTRACTOR_MAPPING
    a						=		resolve_trust_remote_code(
        __lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase							,   __lowerCAmelCase							)

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

    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							(      __lowerCAmelCase			:       str							,   __lowerCAmelCase			:       List[str]							)       ->				Dict:


    """simple docstring"""






    FEATURE_EXTRACTOR_MAPPING.register(__lowerCAmelCase							,   __lowerCAmelCase							)






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A_		:     Optional[int]        =     {
    '''configuration_instructblip''': [
        '''INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''InstructBlipConfig''',
        '''InstructBlipQFormerConfig''',
        '''InstructBlipVisionConfig''',
    ],
    '''processing_instructblip''': ['''InstructBlipProcessor'''],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     A_		:     List[Any]        =     [
         '''INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''InstructBlipQFormerModel''',
         '''InstructBlipPreTrainedModel''',
         '''InstructBlipForConditionalGeneration''',
         '''InstructBlipVisionModel''',
     ]

if TYPE_CHECKING:
     from .configuration_instructblip import (
         INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
         InstructBlipConfig,
         InstructBlipQFormerConfig,
         InstructBlipVisionConfig,
     )
     from .processing_instructblip import InstructBlipProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_instructblip import (
              INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
              InstructBlipForConditionalGeneration,
              InstructBlipPreTrainedModel,
              InstructBlipQFormerModel,
              InstructBlipVisionModel,
          )

else:
     import sys

     A_		:     Tuple        =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

