






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


__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        _SCREAMING_SNAKE_CASE  (				A  :       str  )    -> Union[str, Any]:







   """simple docstring"""
   for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
      if class_name in extractors:
         __snake_case				:      Tuple     							= model_type_to_module_name(A  )

         __snake_case				:      Tuple     							= 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.
   __snake_case				:      List[str]     							= importlib.import_module('transformers'  )
   if hasattr(A  ,		A  ):
      return getattr(A  ,		A  )

   return None




def        _SCREAMING_SNAKE_CASE  (				A  :       Union[str, os.PathLike]  ,		A  :       Optional[Union[str, os.PathLike]] = None  ,		A  :       bool = False  ,		A  :       bool = False  ,		A  :       Optional[Dict[str, str]] = None  ,		A  :       Optional[Union[bool, str]] = None  ,		A  :       Optional[str] = None  ,		A  :       bool = False  ,		**A  :       Optional[Any]  ,		)    -> Optional[int]:







   """simple docstring"""
   __snake_case				:      List[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 a_    :







   def __init__(self)			->      Dict:
      """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     SCREAMING_SNAKE_CASE__					(cls					,   __a					,   **__a)			->      Union[str, Any]:
      """simple docstring"""






      __snake_case				:      List[str]     							= kwargs.pop('config'					,   __a)
      __snake_case				:      Tuple     							= kwargs.pop('trust_remote_code'					,   __a)
      __snake_case				:      List[Any]     							= True

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

      if feature_extractor_class is not None:
         __snake_case				:      List[Any]     							= feature_extractor_class_from_name(__a)

      __snake_case				:      Optional[Any]     							= feature_extractor_auto_map is not None
      __snake_case				:      Union[str, Any]     							= feature_extractor_class is not None or type(__a) in FEATURE_EXTRACTOR_MAPPING
      __snake_case				:      str     							= resolve_trust_remote_code(
          __a					,   __a					,   __a					,   __a)

      if has_remote_code and trust_remote_code:
         __snake_case				:      List[str]     							= get_class_from_dynamic_module(
             __a					,   __a					,   **__a)
         __snake_case				:      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:
         __snake_case				:      Optional[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     SCREAMING_SNAKE_CASE__					(__a					,   __a)			->      Dict:
      """simple docstring"""






      FEATURE_EXTRACTOR_MAPPING.register(__a					,   __a)







'''simple docstring'''






import unittest

from transformers import load_tool
from transformers.utils import is_torch_available


if is_torch_available():
      import torch

from transformers.testing_utils import require_torch

from .test_tools_common import ToolTesterMixin




@require_torch
class a_    (    unittest.TestCase		,      UpperCamelCase_							):







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      __snake_case				:      List[str]     							= load_tool('text-to-speech')
      self.tool.setup()







   def     SCREAMING_SNAKE_CASE__					(self)			->      Optional[Any]:
      """simple docstring"""






      torch.manual_seed(0)
      __snake_case				:      Dict     							= self.tool('hey')
      __snake_case				:      List[Any]     							= result.to_raw()
      self.assertTrue(
          torch.allclose(
              resulting_tensor[:3]					,   torch.tensor([-0.0_005_966_668_832_115_829, -0.0_003_657_640_190_795_064, -0.00_013_439_502_799_883_485])					,   ))







   def     SCREAMING_SNAKE_CASE__					(self)			->      List[Any]:
      """simple docstring"""






      torch.manual_seed(0)
      __snake_case				:      Any     							= self.tool('hey')
      __snake_case				:      Any     							= result.to_raw()
      self.assertTrue(
          torch.allclose(
              resulting_tensor[:3]					,   torch.tensor([-0.0_005_966_668_832_115_829, -0.0_003_657_640_190_795_064, -0.00_013_439_502_799_883_485])					,   ))