



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


lowerCAmelCase: Dict							=						logging.get_logger(__name__)

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

lowerCAmelCase: str							=						_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)
def 				lowerCamelCase__	(						_A    ):
  for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
    if class_name in extractors:
      a						: Any					       =					model_type_to_module_name(_A    )

      a						: Optional[Any]					       =					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						: int					       =					importlib.import_module('transformers'    )
  if hasattr(_A			,      _A    ):
    return getattr(_A			,      _A    )

  return None
def 				lowerCamelCase__	(						_A			,      _A = None			,      _A = False			,      _A = False			,      _A = None			,      _A = None			,      _A = None			,      _A = False			,      **_A			,      ):
  a						: 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			:  Optional[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(__snake_case     )
    def       lowercase_	(				cls			:  int						,      __snake_case			:  str						,      **__snake_case			:  Optional[int]     ):
      a						: Any					       =					kwargs.pop('config'						,      __snake_case     )
      a						: int					       =					kwargs.pop('trust_remote_code'						,      __snake_case     )
      a						: List[str]					       =					True

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

      if feature_extractor_class is not None:
        a						: Optional[int]					       =					feature_extractor_class_from_name(__snake_case     )

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

      if has_remote_code and trust_remote_code:
        a						: int					       =					get_class_from_dynamic_module(
            __snake_case						,      __snake_case						,      **__snake_case     )
        a						: Tuple					       =					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						: List[str]					       =					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       lowercase_	(				__snake_case			:  int						,      __snake_case			:  Dict     ):
      FEATURE_EXTRACTOR_MAPPING.register(__snake_case						,      __snake_case     )




'''simple docstring'''






import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase: Any							=						logging.get_logger(__name__)

class 							a__( lowerCamelCase__     ):
    lowercase__			=   """encoder-decoder"""
    lowercase__			=   True







    def __init__(				self			:  Dict						,      **__snake_case			:  Union[str, Any]     ):
      super().__init__(**__snake_case     )
      assert (
          "encoder" in kwargs and "decoder" in kwargs
      ), "Config has to be initialized with encoder and decoder config"
      a						: List[str]					       =					kwargs.pop('encoder'     )
      a						: Optional[Any]					       =					encoder_config.pop('model_type'     )
      a						: Tuple					       =					kwargs.pop('decoder'     )
      a						: Optional[int]					       =					decoder_config.pop('model_type'     )

      from ..auto.configuration_auto import AutoConfig

      a						: Any					       =					AutoConfig.for_model(__snake_case						,      **__snake_case     )
      a						: Optional[int]					       =					AutoConfig.for_model(__snake_case						,      **__snake_case     )
      a						: Tuple					       =					True







    @classmethod
    def       lowercase_	(				cls			:  int						,      __snake_case			:  PretrainedConfig						,      __snake_case			:  PretrainedConfig						,      **__snake_case			:  Union[str, Any]     ):
      logger.info('Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'     )
      a						: List[Any]					       =					True
      a						: Tuple					       =					True

      return cls(encoder=encoder_config.to_dict()						,      decoder=decoder_config.to_dict()						,      **__snake_case     )







    def       lowercase_	(				self			:  List[Any]     ):
      a						: int					       =					copy.deepcopy(self.__dict__     )
      a						: List[str]					       =					self.encoder.to_dict()
      a						: Optional[int]					       =					self.decoder.to_dict()
      a						: Optional[Any]					       =					self.__class__.model_type
      return output