

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


SCREAMING_SNAKE_CASE						:Union[str, Any]      =			logging.get_logger(__name__)

SCREAMING_SNAKE_CASE						:List[str]      =			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"""),
    ]
)

SCREAMING_SNAKE_CASE						:List[Any]      =			_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       )->		Dict:



    """simple docstring"""






    for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
        if class_name in processors:
            UpperCamelCase_          =		model_type_to_module_name(SCREAMING_SNAKE_CASE_       )

            UpperCamelCase_          =		importlib.import_module(f".{module_name}"       ,		"transformers.models"       )
            try:
                return getattr(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )
            except AttributeError:
                continue

    for processor in PROCESSOR_MAPPING._extra_content.values():
        if getattr(SCREAMING_SNAKE_CASE_       ,		"__name__"       ,		SCREAMING_SNAKE_CASE_       ) == 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_          =		importlib.import_module("transformers"       )
    if hasattr(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ):
        return getattr(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )

    return None






class 		__magic_name__ :






     def __init__(							self     )->			Union[str, Any]:
         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(_lowercase     )
     def      UpperCAmelCase_							(							cls						,		_lowercase						,		**_lowercase     )->			Any:
         UpperCamelCase_          =		kwargs.pop("config"						,		_lowercase     )
         UpperCamelCase_          =		kwargs.pop("trust_remote_code"						,		_lowercase     )
         UpperCamelCase_          =		True

         UpperCamelCase_          =		None
         UpperCamelCase_          =		None

         # First, let's see if we have a preprocessor config.
         # Filter the kwargs for `get_file_from_repo`.
         UpperCamelCase_          =		{
             key: kwargs[key] for key in inspect.signature(_lowercase     ).parameters.keys() if key in kwargs
         }
         # Let's start by checking whether the processor class is saved in an image processor
         UpperCamelCase_          =		get_file_from_repo(
             _lowercase						,		_lowercase						,		**_lowercase     )
         if preprocessor_config_file is not None:
             UpperCamelCase_   ,    UpperCamelCase_          =		ImageProcessingMixin.get_image_processor_dict(_lowercase						,		**_lowercase     )
             UpperCamelCase_          =		config_dict.get("processor_class"						,		_lowercase     )
             if "AutoProcessor" in config_dict.get("auto_map"						,		{}     ):
                 UpperCamelCase_          =		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_   ,    UpperCamelCase_          =		FeatureExtractionMixin.get_feature_extractor_dict(_lowercase						,		**_lowercase     )
             UpperCamelCase_          =		config_dict.get("processor_class"						,		_lowercase     )
             if "AutoProcessor" in config_dict.get("auto_map"						,		{}     ):
                 UpperCamelCase_          =		config_dict["auto_map"]["AutoProcessor"]

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

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

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

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

         if processor_class is not None:
             UpperCamelCase_          =		processor_class_from_name(_lowercase     )

         UpperCamelCase_          =		processor_auto_map is not None
         UpperCamelCase_          =		processor_class is not None or type(_lowercase     ) in PROCESSOR_MAPPING
         UpperCamelCase_          =		resolve_trust_remote_code(
             _lowercase						,		_lowercase						,		_lowercase						,		_lowercase     )

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

         # 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(
                 _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
         except Exception:
             try:
                 return AutoImageProcessor.from_pretrained(
                     _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
             except Exception:
                 pass

             try:
                 return AutoFeatureExtractor.from_pretrained(
                     _lowercase						,		trust_remote_code=_lowercase						,		**_lowercase     )
             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      UpperCAmelCase_							(							_lowercase						,		_lowercase     )->			Optional[Any]:
         PROCESSOR_MAPPING.register(_lowercase						,		_lowercase     )



import unittest

from transformers import ErnieMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        ErnieMForInformationExtraction,
        ErnieMForMultipleChoice,
        ErnieMForQuestionAnswering,
        ErnieMForSequenceClassification,
        ErnieMForTokenClassification,
        ErnieMModel,
    )
    from transformers.models.ernie_m.modeling_ernie_m import ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST







class  __lowerCamelCase				:







      def __init__(     self							,  lowerCamelCase							,  lowerCamelCase=13							,  lowerCamelCase=7							,  lowerCamelCase=True							,  lowerCamelCase=True							,  lowerCamelCase=True							,  lowerCamelCase=99							,  lowerCamelCase=32							,  lowerCamelCase=5							,  lowerCamelCase=4							,  lowerCamelCase=37							,  lowerCamelCase="gelu"							,  lowerCamelCase=0.1							,  lowerCamelCase=0.1							,  lowerCamelCase=512							,  lowerCamelCase=16							,  lowerCamelCase=2							,  lowerCamelCase=0.02							,  lowerCamelCase=3							,  lowerCamelCase=4							,  lowerCamelCase=None							,  )						->       Optional[int]:
        snake_case_       						=      parent
        snake_case_       						=      batch_size
        snake_case_       						=      seq_length
        snake_case_       						=      is_training
        snake_case_       						=      use_input_mask
        snake_case_       						=      use_labels
        snake_case_       						=      vocab_size
        snake_case_       						=      hidden_size
        snake_case_       						=      num_hidden_layers
        snake_case_       						=      num_attention_heads
        snake_case_       						=      intermediate_size
        snake_case_       						=      hidden_act
        snake_case_       						=      hidden_dropout_prob
        snake_case_       						=      attention_probs_dropout_prob
        snake_case_       						=      max_position_embeddings
        snake_case_       						=      type_vocab_size
        snake_case_       						=      type_sequence_label_size
        snake_case_       						=      initializer_range
        snake_case_       						=      num_labels
        snake_case_       						=      num_choices
        snake_case_       						=      scope







      def 	lowerCAmelCase_    (     self   )						->       Optional[Any]:
        snake_case_       						=      ids_tensor([self.batch_size, self.seq_length]							,  self.vocab_size   )

        snake_case_       						=      None
        if self.use_input_mask:
          snake_case_       						=      random_attention_mask([self.batch_size, self.seq_length]   )

        snake_case_       						=      None
        snake_case_       						=      None
        snake_case_       						=      None
        if self.use_labels:
          snake_case_       						=      ids_tensor([self.batch_size]							,  self.type_sequence_label_size   )
          snake_case_       						=      ids_tensor([self.batch_size, self.seq_length]							,  self.num_labels   )
          snake_case_       						=      ids_tensor([self.batch_size]							,  self.num_choices   )

        snake_case_       						=      self.get_config()

        return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels







      def 	lowerCAmelCase_    (     self   )						->       Optional[Any]:
        snake_case_       						=      ids_tensor([self.batch_size, self.seq_length]							,  self.vocab_size   )

        snake_case_       						=      None
        if self.use_input_mask:
          snake_case_       						=      random_attention_mask([self.batch_size, self.seq_length]   )
        snake_case_       						=      self.get_config()

        return config, input_ids, input_mask







      def 	lowerCAmelCase_    (     self   )						->       Optional[int]:
        return ErnieMConfig(
            vocab_size=self.vocab_size							,  hidden_size=self.hidden_size							,  num_hidden_layers=self.num_hidden_layers							,  num_attention_heads=self.num_attention_heads							,  intermediate_size=self.intermediate_size							,  hidden_act=self.hidden_act							,  hidden_dropout_prob=self.hidden_dropout_prob							,  attention_probs_dropout_prob=self.attention_probs_dropout_prob							,  max_position_embeddings=self.max_position_embeddings							,  type_vocab_size=self.type_vocab_size							,  initializer_range=self.initializer_range							,  )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Union[str, Any]:
        snake_case_       						=      ErnieMModel(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      model(lowerCamelCase							,  return_dict=lowerCamelCase   )
        self.parent.assertEqual(result.last_hidden_state.shape							,  (self.batch_size, self.seq_length, self.hidden_size)   )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Tuple:
        snake_case_       						=      ErnieMForQuestionAnswering(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      model(
            lowerCamelCase							,  attention_mask=lowerCamelCase							,  start_positions=lowerCamelCase							,  end_positions=lowerCamelCase							,  )
        self.parent.assertEqual(result.start_logits.shape							,  (self.batch_size, self.seq_length)   )
        self.parent.assertEqual(result.end_logits.shape							,  (self.batch_size, self.seq_length)   )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Tuple:
        snake_case_       						=      ErnieMForInformationExtraction(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      torch.ones_like(lowerCamelCase							,  dtype=torch.floataa   )
        snake_case_       						=      model(
            lowerCamelCase							,  attention_mask=lowerCamelCase							,  start_positions=lowerCamelCase							,  end_positions=lowerCamelCase							,  )
        self.parent.assertEqual(result.start_logits.shape							,  (self.batch_size, self.seq_length)   )
        self.parent.assertEqual(result.end_logits.shape							,  (self.batch_size, self.seq_length)   )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Optional[Any]:
        snake_case_       						=      self.num_labels
        snake_case_       						=      ErnieMForSequenceClassification(lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      model(lowerCamelCase							,  attention_mask=lowerCamelCase							,  labels=lowerCamelCase   )
        self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.num_labels)   )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Union[str, Any]:
        snake_case_       						=      self.num_labels
        snake_case_       						=      ErnieMForTokenClassification(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        input_ids.to(lowerCamelCase   )
        input_mask.to(lowerCamelCase   )
        token_labels.to(lowerCamelCase   )

        snake_case_       						=      model(lowerCamelCase							,  attention_mask=lowerCamelCase							,  labels=lowerCamelCase   )

        self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.seq_length, self.num_labels)   )







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Any:
        snake_case_       						=      self.num_choices
        snake_case_       						=      ErnieMForMultipleChoice(config=lowerCamelCase   )
        model.to(lowerCamelCase   )
        model.eval()
        snake_case_       						=      input_ids.unsqueeze(1   ).expand(-1							,  self.num_choices							,  -1   ).contiguous()
        snake_case_       						=      input_mask.unsqueeze(1   ).expand(-1							,  self.num_choices							,  -1   ).contiguous()
        snake_case_       						=      model(
            lowerCamelCase							,  attention_mask=lowerCamelCase							,  labels=lowerCamelCase							,  )
        self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.num_choices)   )







      def 	lowerCAmelCase_    (     self   )						->       str:
        snake_case_       						=      self.prepare_config_and_inputs()
        (
            (
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				(
            snake_case_
        )						,				
        )       						=      config_and_inputs
        snake_case_       						=      {"""input_ids""": input_ids, """attention_mask""": input_mask}
        return config, inputs_dict







@require_torch
class  __lowerCamelCase				(	__snake_case  ,							__snake_case  ,							unittest.TestCase	):
      lowerCamelCase_	:      Optional[int]          =					(
          (
              ErnieMModel,
              ErnieMForMultipleChoice,
              ErnieMForQuestionAnswering,
              ErnieMForSequenceClassification,
              ErnieMForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      lowerCamelCase_	:      List[str]          =					()
      lowerCamelCase_	:      Optional[int]          =					(
          {
              'feature-extraction': ErnieMModel,
              'question-answering': ErnieMForQuestionAnswering,
              'text-classification': ErnieMForSequenceClassification,
              'token-classification': ErnieMForTokenClassification,
              'zero-shot': ErnieMForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      lowerCamelCase_	:      List[Any]          =					False







      def 	lowerCAmelCase_    (     self							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase							,  lowerCamelCase   )						->       Tuple:
        if pipeline_test_casse_name == "QAPipelineTests":
          return True

        return False







      def 	lowerCAmelCase_    (     self   )						->       Tuple:
        snake_case_       						=      ErnieMModelTester(self   )
        snake_case_       						=      ConfigTester(self							,  config_class=lowerCamelCase							,  hidden_size=37   )







      def 	lowerCAmelCase_    (     self   )						->       Any:
        self.config_tester.run_common_tests()







      def 	lowerCAmelCase_    (     self   )						->       Dict:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       int:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
          snake_case_       						=      type
          self.model_tester.create_and_check_model(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       Dict:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       Optional[Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_information_extraction(*lowerCamelCase   )







      def 	lowerCAmelCase_    (     self   )						->       Union[str, Any]:
        snake_case_       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*lowerCamelCase   )







      @slow
      def 	lowerCAmelCase_    (     self   )						->       int:
        for model_name in ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          snake_case_       						=      ErnieMModel.from_pretrained(lowerCamelCase   )
          self.assertIsNotNone(lowerCamelCase   )







@require_torch
class  __lowerCamelCase				(	unittest.TestCase	):







      @slow
      def 	lowerCAmelCase_    (     self   )						->       List[Any]:
        snake_case_       						=      ErnieMModel.from_pretrained("""susnato/ernie-m-base_pytorch"""   )
        model.eval()
        snake_case_       						=      torch.tensor([[0, 1, 2, 3, 4, 5]]   )
        snake_case_       						=      model(lowerCamelCase   )[0]

        # TODO Replace vocab size
        snake_case_       						=      768

        snake_case_       						=      torch.Size((1, 6, hidden_size)   )
        self.assertEqual(output.shape							,  lowerCamelCase   )

        snake_case_       						=      torch.tensor(
            [[[-0.0012, 0.1245, -0.0214], [-0.0742, 0.0244, -0.0771], [-0.0333, 0.1164, -0.1554]]]   )

        self.assertTrue(torch.allclose(output[:, :3, :3]							,  lowerCamelCase							,  atol=1e-3   )   )