


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


lowerCAmelCase__      		= logging.get_logger(__name__)

lowerCAmelCase__      		= 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'),
    ]
)

lowerCAmelCase__      		= _LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)
def 							_UpperCAmelCase				(UpperCamelCase__     :  str						):
       for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
              if class_name in extractors:
                     _A      :       Dict				    = model_type_to_module_name(UpperCamelCase__						)

                     _A      :       Tuple				    = 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      :       Any				    = 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__     :  Optional[int]				,							):
       _A      :       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__       :




     '''simple docstring'''


     def __init__(						self)			->				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(__lowerCamelCase)
     def  _lowerCamelCase (						cls ,						__lowerCamelCase ,						**__lowerCamelCase)			->				Optional[int]:
            _A      :       Optional[int]				    = kwargs.pop("config" ,						__lowerCamelCase)
            _A      :       Tuple				    = kwargs.pop("trust_remote_code" ,						__lowerCamelCase)
            _A      :       List[Any]				    = True

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

            if feature_extractor_class is not None:
                   _A      :       List[Any]				    = feature_extractor_class_from_name(__lowerCamelCase)

            _A      :       Any				    = feature_extractor_auto_map is not None
            _A      :       Optional[int]				    = feature_extractor_class is not None or type(__lowerCamelCase) in FEATURE_EXTRACTOR_MAPPING
            _A      :       int				    = resolve_trust_remote_code(
                __lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase)

            if has_remote_code and trust_remote_code:
                   _A      :       List[Any]				    = get_class_from_dynamic_module(
                       __lowerCamelCase ,						__lowerCamelCase ,						**__lowerCamelCase)
                   _A      :       List[str]				    = 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      :       Dict				    = 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  _lowerCamelCase (						__lowerCamelCase ,						__lowerCamelCase)			->				Union[str, Any]:
            FEATURE_EXTRACTOR_MAPPING.register(__lowerCamelCase ,						__lowerCamelCase)




import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test







class      lowerCAmelCase__       (				unittest.TestCase):




     '''simple docstring'''


     @parameterized.expand([(None,), ("foo.json",)])
     def  _lowerCamelCase (						self ,						__lowerCamelCase)			->				List[str]:
            _A      :       str				    = GenerationConfig(
                do_sample=__lowerCamelCase ,						temperature=0.7 ,						length_penalty=1.0 ,						bad_words_ids=[[1, 2, 3], [4, 5]] ,						)
            with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(__lowerCamelCase ,						config_name=__lowerCamelCase)
                   _A      :       Tuple				    = GenerationConfig.from_pretrained(__lowerCamelCase ,						config_name=__lowerCamelCase)

            # Checks parameters that were specified
            self.assertEqual(loaded_config.do_sample ,						__lowerCamelCase)
            self.assertEqual(loaded_config.temperature ,						0.7)
            self.assertEqual(loaded_config.length_penalty ,						1.0)
            self.assertEqual(loaded_config.bad_words_ids ,						[[1, 2, 3], [4, 5]])

            # Checks parameters that were not specified (defaults)
            self.assertEqual(loaded_config.top_k ,						5_0)
            self.assertEqual(loaded_config.max_length ,						2_0)
            self.assertEqual(loaded_config.max_time ,						__lowerCamelCase)


     def  _lowerCamelCase (						self)			->				Optional[int]:
            _A      :       Optional[int]				    = AutoConfig.from_pretrained("gpt2")
            _A      :       int				    = GenerationConfig.from_model_config(__lowerCamelCase)
            _A      :       List[Any]				    = GenerationConfig()

            # The generation config has loaded a few non-default parameters from the model config
            self.assertNotEqual(__lowerCamelCase ,						__lowerCamelCase)

            # One of those parameters is eos_token_id -- check if it matches
            self.assertNotEqual(generation_config_from_model.eos_token_id ,						default_generation_config.eos_token_id)
            self.assertEqual(generation_config_from_model.eos_token_id ,						model_config.eos_token_id)


     def  _lowerCamelCase (						self)			->				Optional[Any]:
            _A      :       Optional[Any]				    = GenerationConfig()
            _A      :       List[Any]				    = {
                "max_new_tokens": 1_0_2_4,
                "foo": "bar",
            }
            _A      :       List[str]				    = copy.deepcopy(__lowerCamelCase)
            _A      :       int				    = generation_config.update(**__lowerCamelCase)

            # update_kwargs was not modified (no side effects)
            self.assertEqual(__lowerCamelCase ,						__lowerCamelCase)

            # update_kwargs was used to update the config on valid attributes
            self.assertEqual(generation_config.max_new_tokens ,						1_0_2_4)

            # `.update()` returns a dictionary of unused kwargs
            self.assertEqual(__lowerCamelCase ,						{"foo": "bar"})


     def  _lowerCamelCase (						self)			->				Any:
            _A      :       int				    = GenerationConfig()
            _A      :       int				    = "bar"

            with tempfile.TemporaryDirectory("test-generation-config") as tmp_dir:
                   generation_config.save_pretrained(__lowerCamelCase)

                   _A      :       Any				    = GenerationConfig.from_pretrained(__lowerCamelCase)
            # update_kwargs was used to update the config on valid attributes
            self.assertEqual(new_config.foo ,						"bar")

            _A      :       Optional[Any]				    = GenerationConfig.from_model_config(__lowerCamelCase)
            assert not hasattr(__lowerCamelCase ,						"foo")  # no new kwargs should be initialized if from config


     def  _lowerCamelCase (						self)			->				List[str]:
            _A      :       Union[str, Any]				    = GenerationConfig()
            self.assertEqual(default_config.temperature ,						1.0)
            self.assertEqual(default_config.do_sample ,						__lowerCamelCase)
            self.assertEqual(default_config.num_beams ,						1)

            _A      :       Optional[int]				    = GenerationConfig(
                do_sample=__lowerCamelCase ,						temperature=0.7 ,						length_penalty=1.0 ,						bad_words_ids=[[1, 2, 3], [4, 5]] ,						)
            self.assertEqual(config.temperature ,						0.7)
            self.assertEqual(config.do_sample ,						__lowerCamelCase)
            self.assertEqual(config.num_beams ,						1)

            with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(__lowerCamelCase)
                   _A      :       Optional[int]				    = GenerationConfig.from_pretrained(__lowerCamelCase ,						temperature=1.0)

            self.assertEqual(loaded_config.temperature ,						1.0)
            self.assertEqual(loaded_config.do_sample ,						__lowerCamelCase)
            self.assertEqual(loaded_config.num_beams ,						1)  # default value







@is_staging_test
class      lowerCAmelCase__       (				unittest.TestCase):




     '''simple docstring'''


     @classmethod
     def  _lowerCamelCase (						cls)			->				Optional[int]:
            _A      :       Dict				    = TOKEN
            HfFolder.save_token(__lowerCamelCase)


     @classmethod
     def  _lowerCamelCase (						cls)			->				List[Any]:
            try:
                   delete_repo(token=cls._token ,						repo_id="test-generation-config")
            except HTTPError:
                   pass

            try:
                   delete_repo(token=cls._token ,						repo_id="valid_org/test-generation-config-org")
            except HTTPError:
                   pass


     def  _lowerCamelCase (						self)			->				Any:
            _A      :       Optional[int]				    = GenerationConfig(
                do_sample=__lowerCamelCase ,						temperature=0.7 ,						length_penalty=1.0 ,						)
            config.push_to_hub("test-generation-config" ,						use_auth_token=self._token)

            _A      :       Union[str, Any]				    = GenerationConfig.from_pretrained(F"{USER}/test-generation-config")
            for k, v in config.to_dict().items():
                   if k != "transformers_version":
                          self.assertEqual(__lowerCamelCase ,						getattr(__lowerCamelCase ,						__lowerCamelCase))

        # Reset repo
            delete_repo(token=self._token ,						repo_id="test-generation-config")

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(
                       __lowerCamelCase ,						repo_id="test-generation-config" ,						push_to_hub=__lowerCamelCase ,						use_auth_token=self._token)

            _A      :       Optional[Any]				    = GenerationConfig.from_pretrained(F"{USER}/test-generation-config")
            for k, v in config.to_dict().items():
                   if k != "transformers_version":
                          self.assertEqual(__lowerCamelCase ,						getattr(__lowerCamelCase ,						__lowerCamelCase))


     def  _lowerCamelCase (						self)			->				Union[str, Any]:
            _A      :       Union[str, Any]				    = GenerationConfig(
                do_sample=__lowerCamelCase ,						temperature=0.7 ,						length_penalty=1.0 ,						)
            config.push_to_hub("valid_org/test-generation-config-org" ,						use_auth_token=self._token)

            _A      :       int				    = GenerationConfig.from_pretrained("valid_org/test-generation-config-org")
            for k, v in config.to_dict().items():
                   if k != "transformers_version":
                          self.assertEqual(__lowerCamelCase ,						getattr(__lowerCamelCase ,						__lowerCamelCase))

        # Reset repo
            delete_repo(token=self._token ,						repo_id="valid_org/test-generation-config-org")

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                   config.save_pretrained(
                       __lowerCamelCase ,						repo_id="valid_org/test-generation-config-org" ,						push_to_hub=__lowerCamelCase ,						use_auth_token=self._token)

            _A      :       Optional[int]				    = GenerationConfig.from_pretrained("valid_org/test-generation-config-org")
            for k, v in config.to_dict().items():
                   if k != "transformers_version":
                          self.assertEqual(__lowerCamelCase ,						getattr(__lowerCamelCase ,						__lowerCamelCase))
