




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


_lowerCamelCase							=      logging.get_logger(__name__)

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

_lowerCamelCase							=      _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)





def 							lowerCamelCase    (							UpperCAmelCase_	:      str      )->			Tuple:

       """simple docstring"""




       for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
              if class_name in processors:
                     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 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.
       a			   =importlib.import_module("""transformers"""      )
       if hasattr(UpperCAmelCase_   ,       UpperCAmelCase_      ):
              return getattr(UpperCAmelCase_   ,       UpperCAmelCase_      )

       return None






class        UpperCAmelCase__				:



     '''simple docstring'''
     def __init__(				self	):
            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        lowerCAmelCase__  (				cls ,    _lowerCAmelCase ,    **_lowerCAmelCase	):
            a			   =kwargs.pop("""config""" ,    _lowerCAmelCase	)
            a			   =kwargs.pop("""trust_remote_code""" ,    _lowerCAmelCase	)
            a			   =True

            a			   =None
            a			   =None

            # First, let's see if we have a preprocessor config.
            # Filter the kwargs for `get_file_from_repo`.
            a			   ={
                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
            a			   =get_file_from_repo(
                _lowerCAmelCase ,    _lowerCAmelCase ,    **_lowerCAmelCase	)
            if preprocessor_config_file is not None:
                   a   ,      a			   =ImageProcessingMixin.get_image_processor_dict(_lowerCAmelCase ,    **_lowerCAmelCase	)
                   a			   =config_dict.get("""processor_class""" ,    _lowerCAmelCase	)
                   if "AutoProcessor" in config_dict.get("""auto_map""" ,    {}	):
                          a			   =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:
                   a   ,      a			   =FeatureExtractionMixin.get_feature_extractor_dict(_lowerCAmelCase ,    **_lowerCAmelCase	)
                   a			   =config_dict.get("""processor_class""" ,    _lowerCAmelCase	)
                   if "AutoProcessor" in config_dict.get("""auto_map""" ,    {}	):
                          a			   =config_dict["""auto_map"""]["""AutoProcessor"""]

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

                          a			   =config_dict.get("""processor_class""" ,    _lowerCAmelCase	)
                          if "AutoProcessor" in config_dict.get("""auto_map""" ,    {}	):
                                 a			   =config_dict["""auto_map"""]["""AutoProcessor"""]

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

                   # And check if the config contains the processor class.
                   a			   =getattr(_lowerCAmelCase ,    """processor_class""" ,    _lowerCAmelCase	)
                   if hasattr(_lowerCAmelCase ,    """auto_map"""	) and "AutoProcessor" in config.auto_map:
                          a			   =config.auto_map["""AutoProcessor"""]

            if processor_class is not None:
                   a			   =processor_class_from_name(_lowerCAmelCase	)

            a			   =processor_auto_map is not None
            a			   =processor_class is not None or type(_lowerCAmelCase	) in PROCESSOR_MAPPING
            a			   =resolve_trust_remote_code(
                _lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase	)

            if has_remote_code and trust_remote_code:
                   a			   =get_class_from_dynamic_module(
                       _lowerCAmelCase ,    _lowerCAmelCase ,    **_lowerCAmelCase	)
                   a			   =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        lowerCAmelCase__  (				_lowerCAmelCase ,    _lowerCAmelCase	):
            PROCESSOR_MAPPING.register(_lowerCAmelCase ,    _lowerCAmelCase	)






"""simple docstring"""

import copy

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


UpperCamelCase__			:     List[Any]			       =				logging.get_logger(__name__)

UpperCamelCase__			:     List[str]			       =				{}
class      A__   (   lowercase_  ):
	A_				:					Dict      =   """fsmt_decoder"""




	def __init__( self	:						List[Any]   ,     lowercase	:						Any=0   ,     lowercase	:						Dict=0						)       ->			str:
						super().__init__()
						__snake_case        =						vocab_size
						__snake_case        =						bos_token_id

class      A__   (   lowercase_  ):
	A_				:					Union[str, Any]      =   """fsmt"""
	A_				:					int      =   {"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}




	def __init__( self	:						Optional[Any]   ,     lowercase	:						Any=["en", "de"]   ,     lowercase	:						Optional[int]=42_024   ,     lowercase	:						Optional[int]=42_024   ,     lowercase	:						Tuple="relu"   ,     lowercase	:						Tuple=1_024   ,     lowercase	:						Union[str, Any]=200   ,     lowercase	:						List[str]=1_024   ,     lowercase	:						Tuple=4_096   ,     lowercase	:						int=12   ,     lowercase	:						Any=16   ,     lowercase	:						List[Any]=0.0   ,     lowercase	:						str=4_096   ,     lowercase	:						str=12   ,     lowercase	:						Optional[int]=16   ,     lowercase	:						Dict=0.0   ,     lowercase	:						Any=0.0   ,     lowercase	:						Union[str, Any]=0.1   ,     lowercase	:						Tuple=0.0   ,     lowercase	:						List[str]=0.02   ,     lowercase	:						int=2   ,     lowercase	:						Any=True   ,     lowercase	:						int=True   ,     lowercase	:						int=False   ,     lowercase	:						List[str]=5   ,     lowercase	:						List[Any]=1.0   ,     lowercase	:						Union[str, Any]=False   ,     lowercase	:						Optional[Any]=True   ,     lowercase	:						int=1   ,     lowercase	:						Any=0   ,     lowercase	:						Optional[Any]=2   ,     lowercase	:						Any=2   ,     **lowercase	:						List[Any]   ,     )       ->			Union[str, Any]:
						__snake_case        =						langs
						__snake_case        =						src_vocab_size
						__snake_case        =						tgt_vocab_size
						__snake_case        =						d_model  # encoder_embed_dim and decoder_embed_dim

						__snake_case        =						encoder_ffn_dim
						__snake_case        =						__snake_case        =						encoder_layers
						__snake_case        =						encoder_attention_heads
						__snake_case        =						encoder_layerdrop
						__snake_case        =						decoder_layerdrop
						__snake_case        =						decoder_ffn_dim
						__snake_case        =						decoder_layers
						__snake_case        =						decoder_attention_heads
						__snake_case        =						max_position_embeddings
						__snake_case        =						init_std  # Normal(0, this parameter)
						__snake_case        =						activation_function

						__snake_case        =						DecoderConfig(vocab_size=lowercase   ,     bos_token_id=lowercase						)
						if "decoder" in common_kwargs:
											del common_kwargs["decoder"]

						__snake_case        =						scale_embedding  # scale factor will be sqrt(d_model) if True

						# 3 Types of Dropout
						__snake_case        =						attention_dropout
						__snake_case        =						activation_dropout
						__snake_case        =						dropout

						__snake_case        =						use_cache
						super().__init__(
						    pad_token_id=lowercase   ,     bos_token_id=lowercase   ,     eos_token_id=lowercase   ,     decoder_start_token_id=lowercase   ,     is_encoder_decoder=lowercase   ,     tie_word_embeddings=lowercase   ,     forced_eos_token_id=lowercase   ,     max_length=lowercase   ,     num_beams=lowercase   ,     length_penalty=lowercase   ,     early_stopping=lowercase   ,     **lowercase   ,     )




	def 				a_		( self	:						Union[str, Any]						)       ->			Dict:
						__snake_case        =						copy.deepcopy(self.__dict__						)
						__snake_case        =						self.decoder.to_dict()
						__snake_case        =						self.__class__.model_type
						return output


