
"""simple docstring"""
import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
    from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor






class   _UpperCAmelCase					:
    def __init__(     self    ,     snake_case_    ,     snake_case_=13    ,     snake_case_=32    ,     snake_case_=2    ,     snake_case_=3    ,     snake_case_=16    ,     snake_case_=[1, 2, 1]    ,     snake_case_=[2, 2, 4]    ,     snake_case_=2    ,     snake_case_=2.0    ,     snake_case_=True    ,     snake_case_=0.0    ,     snake_case_=0.0    ,     snake_case_=0.1    ,     snake_case_="gelu"    ,     snake_case_=False    ,     snake_case_=True    ,     snake_case_=0.02    ,     snake_case_=1E-5    ,     snake_case_=True    ,     snake_case_=None    ,     snake_case_=True    ,     snake_case_=10    ,     snake_case_=8    ,     snake_case_=["stage1", "stage2"]    ,     snake_case_=[1, 2]    ,     ):
      _snake_case  :    Optional[Any]            = parent
      _snake_case  :    List[Any]            = batch_size
      _snake_case  :    List[str]            = image_size
      _snake_case  :    str            = patch_size
      _snake_case  :    List[str]            = num_channels
      _snake_case  :    Optional[Any]            = embed_dim
      _snake_case  :    List[str]            = depths
      _snake_case  :    Dict            = num_heads
      _snake_case  :    List[str]            = window_size
      _snake_case  :    Optional[int]            = mlp_ratio
      _snake_case  :    Any            = qkv_bias
      _snake_case  :    List[str]            = hidden_dropout_prob
      _snake_case  :    List[Any]            = attention_probs_dropout_prob
      _snake_case  :    int            = drop_path_rate
      _snake_case  :    Any            = hidden_act
      _snake_case  :    List[str]            = use_absolute_embeddings
      _snake_case  :    List[str]            = patch_norm
      _snake_case  :    Any            = layer_norm_eps
      _snake_case  :    Dict            = initializer_range
      _snake_case  :    int            = is_training
      _snake_case  :    Tuple            = scope
      _snake_case  :    Tuple            = use_labels
      _snake_case  :    Dict            = type_sequence_label_size
      _snake_case  :    int            = encoder_stride
      _snake_case  :    Dict            = out_features
      _snake_case  :    Union[str, Any]            = out_indices
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Any            = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

      _snake_case  :    Any            = None
      if self.use_labels:
        _snake_case  :    int            = ids_tensor([self.batch_size]    ,     self.type_sequence_label_size  )

      _snake_case  :    Optional[int]            = self.get_config()

      return config, pixel_values, labels
    def        lowerCamelCase__						(     self  ):
      return SwinConfig(
          image_size=self.image_size    ,     patch_size=self.patch_size    ,     num_channels=self.num_channels    ,     embed_dim=self.embed_dim    ,     depths=self.depths    ,     num_heads=self.num_heads    ,     window_size=self.window_size    ,     mlp_ratio=self.mlp_ratio    ,     qkv_bias=self.qkv_bias    ,     hidden_dropout_prob=self.hidden_dropout_prob    ,     attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,     drop_path_rate=self.drop_path_rate    ,     hidden_act=self.hidden_act    ,     use_absolute_embeddings=self.use_absolute_embeddings    ,     path_norm=self.patch_norm    ,     layer_norm_eps=self.layer_norm_eps    ,     initializer_range=self.initializer_range    ,     encoder_stride=self.encoder_stride    ,     out_features=self.out_features    ,     out_indices=self.out_indices    ,     )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    int            = SwinModel(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Tuple            = model(snake_case_  )

      _snake_case  :    int            = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
      _snake_case  :    int            = int(config.embed_dim * 2 ** (len(config.depths  ) - 1)  )

      self.parent.assertEqual(result.last_hidden_state.shape    ,     (self.batch_size, expected_seq_len, expected_dim)  )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    List[str]            = SwinBackbone(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    int            = model(snake_case_  )

      # verify hidden states
      self.parent.assertEqual(len(result.feature_maps  )    ,     len(config.out_features  )  )
      self.parent.assertListEqual(list(result.feature_maps[0].shape  )    ,     [self.batch_size, model.channels[0], 16, 16]  )

      # verify channels
      self.parent.assertEqual(len(model.channels  )    ,     len(config.out_features  )  )

      # verify backbone works with out_features=None
      _snake_case  :    Any            = None
      _snake_case  :    Optional[int]            = SwinBackbone(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    int            = model(snake_case_  )

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps  )    ,     1  )
      self.parent.assertListEqual(list(result.feature_maps[0].shape  )    ,     [self.batch_size, model.channels[-1], 4, 4]  )

      # verify channels
      self.parent.assertEqual(len(model.channels  )    ,     1  )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    str            = SwinForMaskedImageModeling(config=snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    Any            = model(snake_case_  )
      self.parent.assertEqual(
          result.logits.shape    ,     (self.batch_size, self.num_channels, self.image_size, self.image_size)  )

      # test greyscale images
      _snake_case  :    List[Any]            = 1
      _snake_case  :    Optional[Any]            = SwinForMaskedImageModeling(snake_case_  )
      model.to(snake_case_  )
      model.eval()

      _snake_case  :    Dict            = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
      _snake_case  :    Tuple            = model(snake_case_  )
      self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, 1, self.image_size, self.image_size)  )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    List[Any]            = self.type_sequence_label_size
      _snake_case  :    Dict            = SwinForImageClassification(snake_case_  )
      model.to(snake_case_  )
      model.eval()
      _snake_case  :    List[str]            = model(snake_case_    ,     labels=snake_case_  )
      self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.type_sequence_label_size)  )

      # test greyscale images
      _snake_case  :    Union[str, Any]            = 1
      _snake_case  :    List[str]            = SwinForImageClassification(snake_case_  )
      model.to(snake_case_  )
      model.eval()

      _snake_case  :    Dict            = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
      _snake_case  :    str            = model(snake_case_  )
      self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.type_sequence_label_size)  )


    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Optional[Any]            = self.prepare_config_and_inputs()
      (
          (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       (
          _snake_case
      )      ,       
      )  :    Optional[Any]            = config_and_inputs
      _snake_case  :    List[str]            = {"pixel_values": pixel_values}
      return config, inputs_dict






@require_torch
class   _UpperCAmelCase					(       _snake_case		,       _snake_case		,       unittest.TestCase):
    __lowercase				:			Tuple	=       (
        (
            SwinModel,
            SwinBackbone,
            SwinForImageClassification,
            SwinForMaskedImageModeling,
        )
        if is_torch_available()
        else ()
    )
    __lowercase				:			Tuple	=       (
        {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
        if is_torch_available()
        else {}
    )
    __lowercase				:			Any	=       True

    __lowercase				:			Dict	=       False
    __lowercase				:			int	=       False
    __lowercase				:			Any	=       False
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Tuple            = SwinModelTester(self  )
      _snake_case  :    List[str]            = ConfigTester(self    ,     config_class=snake_case_    ,     embed_dim=37  )
    def        lowerCamelCase__						(     self  ):
      self.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()
    def        lowerCamelCase__						(     self  ):
      return
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Dict            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case_  )
    @unittest.skip(reason="Got `CUDA error: misaligned address` with PyTorch 2.0.0."  )
    def        lowerCamelCase__						(     self  ):
      pass
    def        lowerCamelCase__						(     self  ):
      super().test_training_gradient_checkpointing()
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Optional[Any]            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    Tuple            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[Any]            = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*snake_case_  )
    @unittest.skip(reason="Swin does not use inputs_embeds"  )
    def        lowerCamelCase__						(     self  ):
      pass
    @unittest.skip(reason="Swin Transformer does not use feedforward chunking"  )
    def        lowerCamelCase__						(     self  ):
      pass
    def        lowerCamelCase__						(     self  ):
      _snake_case      ,       _snake_case  :    Dict            = self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        _snake_case  :    List[Any]            = model_class(snake_case_  )
        self.assertIsInstance(model.get_input_embeddings()    ,     (nn.Module)  )
        _snake_case  :    Any            = model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(snake_case_    ,     nn.Linear  )  )
    def        lowerCamelCase__						(     self  ):
      _snake_case      ,       _snake_case  :    str            = self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        _snake_case  :    int            = model_class(snake_case_  )
        _snake_case  :    str            = inspect.signature(model.forward  )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        _snake_case  :    Optional[int]            = [*signature.parameters.keys()]

        _snake_case  :    Optional[int]            = ["pixel_values"]
        self.assertListEqual(arg_names[:1]    ,     snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case      ,       _snake_case  :    Any            = self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case  :    Dict            = True

      for model_class in self.all_model_classes:
        _snake_case  :    str            = True
        _snake_case  :    Any            = False
        _snake_case  :    Optional[int]            = True
        _snake_case  :    Optional[Any]            = model_class(snake_case_  )
        model.to(snake_case_  )
        model.eval()
        with torch.no_grad():
          _snake_case  :    Union[str, Any]            = model(**self._prepare_for_class(snake_case_    ,     snake_case_  )  )
        _snake_case  :    Dict            = outputs.attentions
        _snake_case  :    int            = len(self.model_tester.depths  )
        self.assertEqual(len(snake_case_  )    ,     snake_case_  )

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        _snake_case  :    List[str]            = True
        _snake_case  :    Optional[Any]            = config.window_size**2
        _snake_case  :    Any            = model_class(snake_case_  )
        model.to(snake_case_  )
        model.eval()
        with torch.no_grad():
          _snake_case  :    Optional[Any]            = model(**self._prepare_for_class(snake_case_    ,     snake_case_  )  )
        _snake_case  :    str            = outputs.attentions
        self.assertEqual(len(snake_case_  )    ,     snake_case_  )

        self.assertListEqual(
            list(attentions[0].shape[-3:]  )    ,     [self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,     )
        _snake_case  :    Union[str, Any]            = len(snake_case_  )

        # Check attention is always last and order is fine
        _snake_case  :    Tuple            = True
        _snake_case  :    int            = True
        _snake_case  :    List[Any]            = model_class(snake_case_  )
        model.to(snake_case_  )
        model.eval()
        with torch.no_grad():
          _snake_case  :    Union[str, Any]            = model(**self._prepare_for_class(snake_case_    ,     snake_case_  )  )

        # also another +1 for reshaped_hidden_states
        _snake_case  :    Optional[Any]            = 1 if model_class.__name__ == "SwinBackbone" else 2
        self.assertEqual(out_len + added_hidden_states    ,     len(snake_case_  )  )

        _snake_case  :    List[str]            = outputs.attentions

        self.assertEqual(len(snake_case_  )    ,     snake_case_  )

        self.assertListEqual(
            list(self_attentions[0].shape[-3:]  )    ,     [self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,     )
    def        lowerCamelCase__						(     self    ,     snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  ):
      _snake_case  :    int            = model_class(snake_case_  )
      model.to(snake_case_  )
      model.eval()

      with torch.no_grad():
        _snake_case  :    Tuple            = model(**self._prepare_for_class(snake_case_    ,     snake_case_  )  )

      _snake_case  :    Union[str, Any]            = outputs.hidden_states

      _snake_case  :    Dict            = getattr(
          self.model_tester    ,     "expected_num_hidden_layers"    ,     len(self.model_tester.depths  ) + 1  )
      self.assertEqual(len(snake_case_  )    ,     snake_case_  )

      # Swin has a different seq_length
      _snake_case  :    Tuple            = (
          config.patch_size
          if isinstance(config.patch_size    ,     collections.abc.Iterable  )
          else (config.patch_size, config.patch_size)
      )

      _snake_case  :    int            = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

      self.assertListEqual(
          list(hidden_states[0].shape[-2:]  )    ,     [num_patches, self.model_tester.embed_dim]    ,     )

      if not model_class.__name__ == "SwinBackbone":
        _snake_case  :    Union[str, Any]            = outputs.reshaped_hidden_states
        self.assertEqual(len(snake_case_  )    ,     snake_case_  )

        _snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case  :    Union[str, Any]            = reshaped_hidden_states[0].shape
        _snake_case  :    Any            = (
            reshaped_hidden_states[0].view(snake_case_    ,     snake_case_    ,     height * width  ).permute(0    ,     2    ,     1  )
        )
        self.assertListEqual(
            list(reshaped_hidden_states.shape[-2:]  )    ,     [num_patches, self.model_tester.embed_dim]    ,     )
    def        lowerCamelCase__						(     self  ):
      _snake_case      ,       _snake_case  :    Any            = self.model_tester.prepare_config_and_inputs_for_common()

      _snake_case  :    Optional[int]            = (
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size    ,     collections.abc.Iterable  )
          else (self.model_tester.image_size, self.model_tester.image_size)
      )

      for model_class in self.all_model_classes:
        _snake_case  :    str            = True
        self.check_hidden_states_output(snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        _snake_case  :    Union[str, Any]            = True

        self.check_hidden_states_output(snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  )
    def        lowerCamelCase__						(     self  ):
      _snake_case      ,       _snake_case  :    str            = self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case  :    Union[str, Any]            = 3

      _snake_case  :    Any            = (
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size    ,     collections.abc.Iterable  )
          else (self.model_tester.image_size, self.model_tester.image_size)
      )
      _snake_case  :    Any            = (
          config.patch_size
          if isinstance(config.patch_size    ,     collections.abc.Iterable  )
          else (config.patch_size, config.patch_size)
      )

      _snake_case  :    str            = image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      _snake_case  :    str            = image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes:
        _snake_case  :    Tuple            = True
        self.check_hidden_states_output(snake_case_    ,     snake_case_    ,     snake_case_    ,     (padded_height, padded_width)  )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        _snake_case  :    List[Any]            = True
        self.check_hidden_states_output(snake_case_    ,     snake_case_    ,     snake_case_    ,     (padded_height, padded_width)  )
    @slow
    def        lowerCamelCase__						(     self  ):
      for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        _snake_case  :    str            = SwinModel.from_pretrained(snake_case_  )
        self.assertIsNotNone(snake_case_  )


    def        lowerCamelCase__						(     self  ):
      _snake_case      ,       _snake_case  :    Tuple            = self.model_tester.prepare_config_and_inputs_for_common()

      _snake_case  :    List[str]            = _config_zero_init(snake_case_  )
      for model_class in self.all_model_classes:
        _snake_case  :    Optional[int]            = model_class(config=snake_case_  )
        for name, param in model.named_parameters():
          if "embeddings" not in name and param.requires_grad:
            self.assertIn(
                ((param.data.mean() * 1E9).round() / 1E9).item()    ,     [0.0, 1.0]    ,     msg=F'Parameter {name} of model {model_class} seems not properly initialized'    ,     )






@require_vision
@require_torch
class   _UpperCAmelCase					(       unittest.TestCase):
    @cached_property
    def        lowerCamelCase__						(     self  ):
      return (
          AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224"  )
          if is_vision_available()
          else None
      )


    @slow
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[str]            = SwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"  ).to(snake_case_  )
      _snake_case  :    Optional[int]            = self.default_image_processor

      _snake_case  :    Dict            = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
      _snake_case  :    int            = image_processor(images=snake_case_    ,     return_tensors="pt"  ).to(snake_case_  )

      # forward pass
      with torch.no_grad():
        _snake_case  :    Optional[Any]            = model(**snake_case_  )

      # verify the logits
      _snake_case  :    Tuple            = torch.Size((1, 10_00)  )
      self.assertEqual(outputs.logits.shape    ,     snake_case_  )
      _snake_case  :    List[str]            = torch.tensor([-0.0948, -0.6454, -0.0921]  ).to(snake_case_  )
      self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,     snake_case_    ,     atol=1E-4  )  )






@require_torch
class   _UpperCAmelCase					(       unittest.TestCase		,       _snake_case):
    __lowercase				:			Optional[int]	=       (SwinBackbone,) if is_torch_available() else ()
    __lowercase				:			Optional[Any]	=       SwinConfig
    def        lowerCamelCase__						(     self  ):
      _snake_case  :    List[Any]            = SwinModelTester(self  )



"""simple docstring"""
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


_a   :      Optional[int]       =				logging.get_logger(__name__)

_a   :      Tuple       =				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"""),
    ]
)

_a   :      Any       =				_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)
def 					a__ ( a :					str		):

  """simple docstring"""







  for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
    if class_name in processors:
      _snake_case  :    Dict            = model_type_to_module_name(a		)

      _snake_case  :    Optional[int]            = importlib.import_module(f'.{module_name}'							,  "transformers.models"		)
      try:
        return getattr(a							,  a		)
      except AttributeError:
        continue

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

  return None






class   _UpperCAmelCase					:
    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(snake_case_  )
    def        lowerCamelCase__						(     cls    ,     snake_case_    ,     **snake_case_  ):
      _snake_case  :    str            = kwargs.pop("config"    ,     snake_case_  )
      _snake_case  :    Dict            = kwargs.pop("trust_remote_code"    ,     snake_case_  )
      _snake_case  :    Tuple            = True

      _snake_case  :    List[str]            = None
      _snake_case  :    Optional[Any]            = None

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

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

          _snake_case  :    List[Any]            = config_dict.get("processor_class"    ,     snake_case_  )
          if "AutoProcessor" in config_dict.get("auto_map"    ,     {}  ):
            _snake_case  :    Tuple            = config_dict["auto_map"]["AutoProcessor"]

      if processor_class is None:
        # Otherwise, load config, if it can be loaded.
        if not isinstance(snake_case_    ,     snake_case_  ):
          _snake_case  :    Union[str, Any]            = AutoConfig.from_pretrained(
              snake_case_    ,     trust_remote_code=snake_case_    ,     **snake_case_  )

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

      if processor_class is not None:
        _snake_case  :    Optional[int]            = processor_class_from_name(snake_case_  )

      _snake_case  :    Optional[int]            = processor_auto_map is not None
      _snake_case  :    Any            = processor_class is not None or type(snake_case_  ) in PROCESSOR_MAPPING
      _snake_case  :    Union[str, Any]            = resolve_trust_remote_code(
          snake_case_    ,     snake_case_    ,     snake_case_    ,     snake_case_  )

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

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

        try:
          return AutoFeatureExtractor.from_pretrained(
              snake_case_    ,     trust_remote_code=snake_case_    ,     **snake_case_  )
        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__						(     snake_case_    ,     snake_case_  ):
      PROCESSOR_MAPPING.register(snake_case_    ,     snake_case_  )

