





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

a__      :     List[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'),
    ]
)

a__      :     str         =		_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)

def      UpperCAmelCase_    (    _UpperCAmelCase							:str				)	->				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							:Dict  ,						)	->				List[Any]:
     '''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 UpperCAmelCase_				:


  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(__snake_case )
  def 						__UpperCAmelCase     (							cls ,__snake_case ,**__snake_case ):



       """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 						__UpperCAmelCase     (							__snake_case ,__snake_case ):



       """simple docstring"""





       FEATURE_EXTRACTOR_MAPPING.register(__snake_case ,__snake_case )










import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device


a__      :     Optional[int]         =		False





class UpperCAmelCase_				( unittest.TestCase ):
  pass





@slow
@require_torch_gpu
class UpperCAmelCase_				( unittest.TestCase ):


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       VersatileDiffusionImageVariationPipeline.from_pretrained('''shi-labs/versatile-diffusion''' )
       pipe.to(__snake_case )
       pipe.set_progress_bar_config(disable=__snake_case )

       A_          =       load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg''' )
       A_          =       torch.manual_seed(0 )
       A_          =       pipe(
           image=__snake_case ,generator=__snake_case ,guidance_scale=7.5 ,num_inference_steps=5_0 ,output_type='''numpy''' ,).images

       A_          =       image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1]

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       A_          =       np.array([0.0441, 0.0469, 0.0507, 0.0575, 0.0632, 0.0650, 0.0865, 0.0909, 0.0945] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2



