
import importlib
import inspect
import json
import os
from collections import OrderedDict

# 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 ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import 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,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


__snake_case					:							Any           =							logging.get_logger(__name__)

__snake_case					:							Any           =							OrderedDict(
    [
        ('align', 'AlignProcessor'),
        ('altclip', 'AltCLIPProcessor'),
        ('bark', 'BarkProcessor'),
        ('blip', 'BlipProcessor'),
        ('blip-2', 'Blip2Processor'),
        ('bridgetower', 'BridgeTowerProcessor'),
        ('chinese_clip', 'ChineseCLIPProcessor'),
        ('clap', 'ClapProcessor'),
        ('clip', 'CLIPProcessor'),
        ('clipseg', 'CLIPSegProcessor'),
        ('flava', 'FlavaProcessor'),
        ('git', 'GitProcessor'),
        ('groupvit', 'CLIPProcessor'),
        ('hubert', 'Wav2Vec2Processor'),
        ('instructblip', 'InstructBlipProcessor'),
        ('layoutlmv2', 'LayoutLMv2Processor'),
        ('layoutlmv3', 'LayoutLMv3Processor'),
        ('markuplm', 'MarkupLMProcessor'),
        ('mctct', 'MCTCTProcessor'),
        ('mgp-str', 'MgpstrProcessor'),
        ('oneformer', 'OneFormerProcessor'),
        ('owlvit', 'OwlViTProcessor'),
        ('pix2struct', 'Pix2StructProcessor'),
        ('sam', 'SamProcessor'),
        ('sew', 'Wav2Vec2Processor'),
        ('sew-d', 'Wav2Vec2Processor'),
        ('speech_to_text', 'Speech2TextProcessor'),
        ('speech_to_text_2', 'Speech2Text2Processor'),
        ('speecht5', 'SpeechT5Processor'),
        ('trocr', 'TrOCRProcessor'),
        ('tvlt', 'TvltProcessor'),
        ('unispeech', 'Wav2Vec2Processor'),
        ('unispeech-sat', 'Wav2Vec2Processor'),
        ('vilt', 'ViltProcessor'),
        ('vision-text-dual-encoder', 'VisionTextDualEncoderProcessor'),
        ('wav2vec2', 'Wav2Vec2Processor'),
        ('wav2vec2-conformer', 'Wav2Vec2Processor'),
        ('wavlm', 'Wav2Vec2Processor'),
        ('whisper', 'WhisperProcessor'),
        ('xclip', 'XCLIPProcessor'),
    ]
)

__snake_case					:							str           =							_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)




def 		A						(  SCREAMING_SNAKE_CASE							):




			"""simple docstring"""


			for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
						if class_name in processors:
									UpperCAmelCase__		:Union[str, Any] 		=    model_type_to_module_name(UpperCAmelCase_							)

									UpperCAmelCase__		:Dict 		=    importlib.import_module(f""".{module_name}"""     ,						'transformers.models'							)
									try:
												return getattr(UpperCAmelCase_     ,						UpperCAmelCase_							)
									except AttributeError:
												continue

			for processor in PROCESSOR_MAPPING._extra_content.values():
						if getattr(UpperCAmelCase_     ,						'__name__'     ,						UpperCAmelCase_							) == class_name:
									return processor

    # 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.
			UpperCAmelCase__		:Union[str, Any] 		=    importlib.import_module('transformers'							)
			if hasattr(UpperCAmelCase_     ,						UpperCAmelCase_							):
						return getattr(UpperCAmelCase_     ,						UpperCAmelCase_							)

			return None




class 	UpperCamelCase__       :

						'''simple docstring'''



						def __init__(  self	)  ->List[str]:
									raise EnvironmentError(
									    'AutoProcessor is designed to be instantiated '
									    'using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method.'	)


						@classmethod
						@replace_list_option_in_docstrings(__lowerCAmelCase	)
						def    A__       (  cls  , A  , **A	)  ->Dict:
									UpperCAmelCase__		:Optional[Any] 		=    kwargs.pop('config'  , __lowerCAmelCase	)
									UpperCAmelCase__		:Any 		=    kwargs.pop('trust_remote_code'  , __lowerCAmelCase	)
									UpperCAmelCase__		:List[Any] 		=    True

									UpperCAmelCase__		:Dict 		=    None
									UpperCAmelCase__		:str 		=    None

									# First, let's see if we have a preprocessor config.
									# Filter the kwargs for `get_file_from_repo`.
									UpperCAmelCase__		:List[Any] 		=    {
									    key: kwargs[key] for key in inspect.signature(__lowerCAmelCase	).parameters.keys() if key in kwargs
									}
									# Let's start by checking whether the processor class is saved in an image processor
									UpperCAmelCase__		:Tuple 		=    get_file_from_repo(
									    __lowerCAmelCase  , __lowerCAmelCase  , **__lowerCAmelCase	)
									if preprocessor_config_file is not None:
												UpperCAmelCase__		:Dict 		=    ImageProcessingMixin.get_image_processor_dict(__lowerCAmelCase  , **__lowerCAmelCase	)
												UpperCAmelCase__		:Any 		=    config_dict.get('processor_class'  , __lowerCAmelCase	)
												if "AutoProcessor" in config_dict.get('auto_map'  , {}	):
															UpperCAmelCase__		:Dict 		=    config_dict["""auto_map"""]["""AutoProcessor"""]

        # If not found, let's check whether the processor class is saved in a feature extractor config
									if preprocessor_config_file is not None and processor_class is None:
												UpperCAmelCase__		:Any 		=    FeatureExtractionMixin.get_feature_extractor_dict(__lowerCAmelCase  , **__lowerCAmelCase	)
												UpperCAmelCase__		:Optional[Any] 		=    config_dict.get('processor_class'  , __lowerCAmelCase	)
												if "AutoProcessor" in config_dict.get('auto_map'  , {}	):
															UpperCAmelCase__		:Any 		=    config_dict["""auto_map"""]["""AutoProcessor"""]

									if processor_class is None:
												# Next, let's check whether the processor class is saved in a tokenizer
												UpperCAmelCase__		:Dict 		=    get_file_from_repo(
												    __lowerCAmelCase  , __lowerCAmelCase  , **__lowerCAmelCase	)
												if tokenizer_config_file is not None:
															with open(__lowerCAmelCase  , encoding='utf-8'	) as reader:
																		UpperCAmelCase__		:Optional[int] 		=    json.load(__lowerCAmelCase	)

															UpperCAmelCase__		:str 		=    config_dict.get('processor_class'  , __lowerCAmelCase	)
															if "AutoProcessor" in config_dict.get('auto_map'  , {}	):
																		UpperCAmelCase__		:Dict 		=    config_dict["""auto_map"""]["""AutoProcessor"""]

									if processor_class is None:
												# Otherwise, load config, if it can be loaded.
												if not isinstance(__lowerCAmelCase  , __lowerCAmelCase	):
															UpperCAmelCase__		:Any 		=    AutoConfig.from_pretrained(
															    __lowerCAmelCase  , trust_remote_code=__lowerCAmelCase  , **__lowerCAmelCase	)

												# And check if the config contains the processor class.
												UpperCAmelCase__		:Any 		=    getattr(__lowerCAmelCase  , 'processor_class'  , __lowerCAmelCase	)
												if hasattr(__lowerCAmelCase  , 'auto_map'	) and "AutoProcessor" in config.auto_map:
															UpperCAmelCase__		:List[Any] 		=    config.auto_map["""AutoProcessor"""]

									if processor_class is not None:
												UpperCAmelCase__		:List[str] 		=    processor_class_from_name(__lowerCAmelCase	)

									UpperCAmelCase__		:Optional[int] 		=    processor_auto_map is not None
									UpperCAmelCase__		:List[Any] 		=    processor_class is not None or type(__lowerCAmelCase	) in PROCESSOR_MAPPING
									UpperCAmelCase__		:List[Any] 		=    resolve_trust_remote_code(
									    __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase	)

									if has_remote_code and trust_remote_code:
												UpperCAmelCase__		:List[Any] 		=    get_class_from_dynamic_module(
												    __lowerCAmelCase  , __lowerCAmelCase  , **__lowerCAmelCase	)
												UpperCAmelCase__		:Dict 		=    kwargs.pop('code_revision'  , __lowerCAmelCase	)
												if os.path.isdir(__lowerCAmelCase	):
															processor_class.register_for_auto_class()
												return processor_class.from_pretrained(
												    __lowerCAmelCase  , trust_remote_code=__lowerCAmelCase  , **__lowerCAmelCase	)
									elif processor_class is not None:
												return processor_class.from_pretrained(
												    __lowerCAmelCase  , trust_remote_code=__lowerCAmelCase  , **__lowerCAmelCase	)
									# Last try: we use the PROCESSOR_MAPPING.
									elif type(__lowerCAmelCase	) in PROCESSOR_MAPPING:
												return PROCESSOR_MAPPING[type(__lowerCAmelCase	)].from_pretrained(__lowerCAmelCase  , **__lowerCAmelCase	)

									# At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
									# tokenizer.
									try:
												return AutoTokenizer.from_pretrained(
												    __lowerCAmelCase  , trust_remote_code=__lowerCAmelCase  , **__lowerCAmelCase	)
									except Exception:
												try:
															return AutoImageProcessor.from_pretrained(
															    __lowerCAmelCase  , trust_remote_code=__lowerCAmelCase  , **__lowerCAmelCase	)
												except Exception:
															pass

												try:
															return AutoFeatureExtractor.from_pretrained(
															    __lowerCAmelCase  , trust_remote_code=__lowerCAmelCase  , **__lowerCAmelCase	)
												except Exception:
															pass

									raise ValueError(
									    F"""Unrecognized processing class in {pretrained_model_name_or_path}. Can\'t instantiate a processor, a """
									    'tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains'
									    'the files of at least one of those processing classes.'	)


						@staticmethod
						def    A__       (  A  , A	)  ->Any:
									PROCESSOR_MAPPING.register(__lowerCAmelCase  , __lowerCAmelCase	)











'''simple docstring'''





import functools
import operator

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


a		:	Dict       =      logging.get_logger(__name__)

a		:	Optional[int]       =      {
    '''facebook/hubert-base-ls960''': '''https://huggingface.co/facebook/hubert-base-ls960/resolve/main/config.json''',
    # See all Hubert models at https://huggingface.co/models?filter=hubert
}




class      UpperCamelCase       (	snake_case__       ):
  a     :int          =					'hubert'



  def __init__(			self		,     __lowerCAmelCase=32		,     __lowerCAmelCase=768		,     __lowerCAmelCase=12		,     __lowerCAmelCase=12		,     __lowerCAmelCase=3072		,     __lowerCAmelCase="gelu"		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=True		,     __lowerCAmelCase=0.0		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.1		,     __lowerCAmelCase=0.02		,     __lowerCAmelCase=1e-5		,     __lowerCAmelCase="group"		,     __lowerCAmelCase="gelu"		,     __lowerCAmelCase=(512, 512, 512, 512, 512, 512, 512)		,     __lowerCAmelCase=(5, 2, 2, 2, 2, 2, 2)		,     __lowerCAmelCase=(10, 3, 3, 3, 3, 2, 2)		,     __lowerCAmelCase=False		,     __lowerCAmelCase=128		,     __lowerCAmelCase=16		,     __lowerCAmelCase=False		,     __lowerCAmelCase=True		,     __lowerCAmelCase=0.05		,     __lowerCAmelCase=10		,     __lowerCAmelCase=2		,     __lowerCAmelCase=0.0		,     __lowerCAmelCase=10		,     __lowerCAmelCase=0		,     __lowerCAmelCase="sum"		,     __lowerCAmelCase=False		,     __lowerCAmelCase=False		,     __lowerCAmelCase=256		,     __lowerCAmelCase=0		,     __lowerCAmelCase=1		,     __lowerCAmelCase=2		,     **__lowerCAmelCase		,     ):







      '''simple docstring'''


      super().__init__(**__lowerCAmelCase		,     pad_token_id=__lowerCAmelCase		,     bos_token_id=__lowerCAmelCase		,     eos_token_id=__lowerCAmelCase )
      _a				:							List[Any]							       =      hidden_size
      _a				:							Union[str, Any]							       =      feat_extract_norm
      _a				:							Any							       =      feat_extract_activation
      _a				:							Tuple							       =      list(__lowerCAmelCase )
      _a				:							List[Any]							       =      list(__lowerCAmelCase )
      _a				:							Any							       =      list(__lowerCAmelCase )
      _a				:							Optional[int]							       =      conv_bias
      _a				:							Tuple							       =      num_conv_pos_embeddings
      _a				:							Optional[int]							       =      num_conv_pos_embedding_groups
      _a				:							Tuple							       =      len(self.conv_dim )
      _a				:							int							       =      num_hidden_layers
      _a				:							Optional[Any]							       =      intermediate_size
      _a				:							Dict							       =      hidden_act
      _a				:							Tuple							       =      num_attention_heads
      _a				:							Tuple							       =      hidden_dropout
      _a				:							str							       =      attention_dropout
      _a				:							Union[str, Any]							       =      activation_dropout
      _a				:							int							       =      feat_proj_layer_norm
      _a				:							List[Any]							       =      feat_proj_dropout
      _a				:							Any							       =      final_dropout
      _a				:							Dict							       =      layerdrop
      _a				:							List[str]							       =      layer_norm_eps
      _a				:							Any							       =      initializer_range
      _a				:							List[str]							       =      vocab_size
      _a				:							int							       =      do_stable_layer_norm
      _a				:							str							       =      use_weighted_layer_sum
      _a				:							Optional[Any]							       =      classifier_proj_size

      if (
          (len(self.conv_stride ) != self.num_feat_extract_layers)
          or (len(self.conv_kernel ) != self.num_feat_extract_layers)
          or (len(self.conv_dim ) != self.num_feat_extract_layers)
      ):
          raise ValueError(
              """Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="""
              """ `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="""
              f''' {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`,'''
              f''' `len(config.conv_kernel) = {len(self.conv_kernel )}`.''' )

      # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
      _a				:							str							       =      apply_spec_augment
      _a				:							List[Any]							       =      mask_time_prob
      _a				:							List[Any]							       =      mask_time_length
      _a				:							List[Any]							       =      mask_time_min_masks
      _a				:							Union[str, Any]							       =      mask_feature_prob
      _a				:							str							       =      mask_feature_length
      _a				:							Any							       =      mask_feature_min_masks

      # ctc loss
      _a				:							Tuple							       =      ctc_loss_reduction
      _a				:							Optional[int]							       =      ctc_zero_infinity



  @property
  def     a_							(			self ):







      '''simple docstring'''


      return functools.reduce(operator.mul		,     self.conv_stride		,     1 )


