

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


__UpperCAmelCase     					=  logging.get_logger(__name__)

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

__UpperCAmelCase     					=  _LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)







def 						_snake_case		(     SCREAMING_SNAKE_CASE					)							->   Any:

     """simple docstring"""







     for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
          if class_name in processors:
               _lowerCAmelCase :       List[Any]	   =     model_type_to_module_name(SCREAMING_SNAKE_CASE					)

               _lowerCAmelCase :       int	   =     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.
     _lowerCAmelCase :       Any	   =     importlib.import_module("transformers"					)
     if hasattr(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE					):
          return getattr(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE					)

     return None





class A__     :



 """simple docstring"""







 def __init__(		self			:						List[Any]							):






      '''simple docstring'''




      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(A_							)
 def  __magic_name__							(		cls			:						Tuple  ,    A_			:						Any  ,    **A_			:						List[str]							):






      '''simple docstring'''




      _lowerCAmelCase :       Dict	   =     kwargs.pop("config"  ,    A_							)
      _lowerCAmelCase :       str	   =     kwargs.pop("trust_remote_code"  ,    A_							)
      _lowerCAmelCase :       List[Any]	   =     True

      _lowerCAmelCase :       str	   =     None
      _lowerCAmelCase :       List[str]	   =     None

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

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

                _lowerCAmelCase :       Union[str, Any]	   =     config_dict.get("processor_class"  ,    A_							)
                if "AutoProcessor" in config_dict.get("auto_map"  ,    {}							):
                     _lowerCAmelCase :       Tuple	   =     config_dict["auto_map"]["AutoProcessor"]

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

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

      if processor_class is not None:
           _lowerCAmelCase :       Any	   =     processor_class_from_name(A_							)

      _lowerCAmelCase :       List[Any]	   =     processor_auto_map is not None
      _lowerCAmelCase :       str	   =     processor_class is not None or type(A_							) in PROCESSOR_MAPPING
      _lowerCAmelCase :       Union[str, Any]	   =     resolve_trust_remote_code(
          A_  ,    A_  ,    A_  ,    A_							)

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

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

           try:
                return AutoFeatureExtractor.from_pretrained(
                    A_  ,    trust_remote_code=A_  ,    **A_							)
           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  __magic_name__							(		A_			:						List[str]  ,    A_			:						Tuple							):






      '''simple docstring'''




      PROCESSOR_MAPPING.register(A_  ,    A_							)









import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import ConvNextImageProcessor





class A__     (			unittest.TestCase			):



 """simple docstring"""







 def __init__(		self			:						Optional[Any]  ,    A_			:						Union[str, Any]  ,    A_			:						List[Any]=7  ,    A_			:						Optional[Any]=3  ,    A_			:						Optional[int]=1_8  ,    A_			:						Dict=3_0  ,    A_			:						Dict=4_0_0  ,    A_			:						List[Any]=True  ,    A_			:						int=None  ,    A_			:						List[Any]=0.875  ,    A_			:						List[str]=True  ,    A_			:						List[Any]=[0.5, 0.5, 0.5]  ,    A_			:						Optional[Any]=[0.5, 0.5, 0.5]  ,    ):






      '''simple docstring'''




      _lowerCAmelCase :       List[str]	   =     size if size is not None else {"shortest_edge": 2_0}
      _lowerCAmelCase :       Union[str, Any]	   =     parent
      _lowerCAmelCase :       int	   =     batch_size
      _lowerCAmelCase :       Any	   =     num_channels
      _lowerCAmelCase :       str	   =     image_size
      _lowerCAmelCase :       List[Any]	   =     min_resolution
      _lowerCAmelCase :       Tuple	   =     max_resolution
      _lowerCAmelCase :       Any	   =     do_resize
      _lowerCAmelCase :       List[str]	   =     size
      _lowerCAmelCase :       List[str]	   =     crop_pct
      _lowerCAmelCase :       Tuple	   =     do_normalize
      _lowerCAmelCase :       int	   =     image_mean
      _lowerCAmelCase :       Dict	   =     image_std


 def  __magic_name__							(		self			:						Dict							):






      '''simple docstring'''




      return {
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_normalize": self.do_normalize,
          "do_resize": self.do_resize,
          "size": self.size,
          "crop_pct": self.crop_pct,
      }





@require_torch
@require_vision
class A__     (			A	,		unittest.TestCase			):



 """simple docstring"""







 _lowercase  :       int  			=    ConvNextImageProcessor if is_vision_available() else None

 def  __magic_name__							(		self			:						Dict							):






      '''simple docstring'''




      _lowerCAmelCase :       int	   =     ConvNextImageProcessingTester(self							)

 @property
 def  __magic_name__							(		self			:						str							):






      '''simple docstring'''




      return self.image_processor_tester.prepare_image_processor_dict()

 def  __magic_name__							(		self			:						Union[str, Any]							):






      '''simple docstring'''




      _lowerCAmelCase :       int	   =     self.image_processing_class(**self.image_processor_dict							)
      self.assertTrue(hasattr(A_  ,    "do_resize"							)							)
      self.assertTrue(hasattr(A_  ,    "size"							)							)
      self.assertTrue(hasattr(A_  ,    "crop_pct"							)							)
      self.assertTrue(hasattr(A_  ,    "do_normalize"							)							)
      self.assertTrue(hasattr(A_  ,    "image_mean"							)							)
      self.assertTrue(hasattr(A_  ,    "image_std"							)							)

 def  __magic_name__							(		self			:						Optional[int]							):






      '''simple docstring'''




      _lowerCAmelCase :       str	   =     self.image_processing_class.from_dict(self.image_processor_dict							)
      self.assertEqual(image_processor.size  ,    {"shortest_edge": 2_0}							)

      _lowerCAmelCase :       Optional[int]	   =     self.image_processing_class.from_dict(self.image_processor_dict  ,    size=4_2							)
      self.assertEqual(image_processor.size  ,    {"shortest_edge": 4_2}							)

 def  __magic_name__							(		self			:						List[str]							):






      '''simple docstring'''




      pass

 def  __magic_name__							(		self			:						Tuple							):






      '''simple docstring'''




      _lowerCAmelCase :       Optional[int]	   =     self.image_processing_class(**self.image_processor_dict							)
      # create random PIL images
      _lowerCAmelCase :       Tuple	   =     prepare_image_inputs(self.image_processor_tester  ,    equal_resolution=A_							)
      for image in image_inputs:
           self.assertIsInstance(A_  ,    Image.Image							)

      # Test not batched input
      _lowerCAmelCase :       List[Any]	   =     image_processing(image_inputs[0]  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

      # Test batched
      _lowerCAmelCase :       Any	   =     image_processing(A_  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

 def  __magic_name__							(		self			:						Optional[int]							):






      '''simple docstring'''




      _lowerCAmelCase :       Dict	   =     self.image_processing_class(**self.image_processor_dict							)
      # create random numpy tensors
      _lowerCAmelCase :       str	   =     prepare_image_inputs(self.image_processor_tester  ,    equal_resolution=A_  ,    numpify=A_							)
      for image in image_inputs:
           self.assertIsInstance(A_  ,    np.ndarray							)

      # Test not batched input
      _lowerCAmelCase :       str	   =     image_processing(image_inputs[0]  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

      # Test batched
      _lowerCAmelCase :       Optional[Any]	   =     image_processing(A_  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )


 def  __magic_name__							(		self			:						List[Any]							):






      '''simple docstring'''




      _lowerCAmelCase :       Tuple	   =     self.image_processing_class(**self.image_processor_dict							)
      # create random PyTorch tensors
      _lowerCAmelCase :       List[str]	   =     prepare_image_inputs(self.image_processor_tester  ,    equal_resolution=A_  ,    torchify=A_							)
      for image in image_inputs:
           self.assertIsInstance(A_  ,    torch.Tensor							)

      # Test not batched input
      _lowerCAmelCase :       Any	   =     image_processing(image_inputs[0]  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              1,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )

      # Test batched
      _lowerCAmelCase :       Union[str, Any]	   =     image_processing(A_  ,    return_tensors="pt"							).pixel_values
      self.assertEqual(
          encoded_images.shape  ,    (
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.size["shortest_edge"],
              self.image_processor_tester.size["shortest_edge"],
          )  ,    )






