


"""simple docstring"""





import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_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,
)


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

snake_case__						:   Optional[int]			 = OrderedDict(
    [
        ('''align''', '''EfficientNetImageProcessor'''),
        ('''beit''', '''BeitImageProcessor'''),
        ('''bit''', '''BitImageProcessor'''),
        ('''blip''', '''BlipImageProcessor'''),
        ('''blip-2''', '''BlipImageProcessor'''),
        ('''bridgetower''', '''BridgeTowerImageProcessor'''),
        ('''chinese_clip''', '''ChineseCLIPImageProcessor'''),
        ('''clip''', '''CLIPImageProcessor'''),
        ('''clipseg''', '''ViTImageProcessor'''),
        ('''conditional_detr''', '''ConditionalDetrImageProcessor'''),
        ('''convnext''', '''ConvNextImageProcessor'''),
        ('''convnextv2''', '''ConvNextImageProcessor'''),
        ('''cvt''', '''ConvNextImageProcessor'''),
        ('''data2vec-vision''', '''BeitImageProcessor'''),
        ('''deformable_detr''', '''DeformableDetrImageProcessor'''),
        ('''deit''', '''DeiTImageProcessor'''),
        ('''deta''', '''DetaImageProcessor'''),
        ('''detr''', '''DetrImageProcessor'''),
        ('''dinat''', '''ViTImageProcessor'''),
        ('''donut-swin''', '''DonutImageProcessor'''),
        ('''dpt''', '''DPTImageProcessor'''),
        ('''efficientformer''', '''EfficientFormerImageProcessor'''),
        ('''efficientnet''', '''EfficientNetImageProcessor'''),
        ('''flava''', '''FlavaImageProcessor'''),
        ('''focalnet''', '''BitImageProcessor'''),
        ('''git''', '''CLIPImageProcessor'''),
        ('''glpn''', '''GLPNImageProcessor'''),
        ('''groupvit''', '''CLIPImageProcessor'''),
        ('''imagegpt''', '''ImageGPTImageProcessor'''),
        ('''instructblip''', '''BlipImageProcessor'''),
        ('''layoutlmv2''', '''LayoutLMv2ImageProcessor'''),
        ('''layoutlmv3''', '''LayoutLMv3ImageProcessor'''),
        ('''levit''', '''LevitImageProcessor'''),
        ('''mask2former''', '''Mask2FormerImageProcessor'''),
        ('''maskformer''', '''MaskFormerImageProcessor'''),
        ('''mgp-str''', '''ViTImageProcessor'''),
        ('''mobilenet_v1''', '''MobileNetV1ImageProcessor'''),
        ('''mobilenet_v2''', '''MobileNetV2ImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevit''', '''MobileViTImageProcessor'''),
        ('''mobilevitv2''', '''MobileViTImageProcessor'''),
        ('''nat''', '''ViTImageProcessor'''),
        ('''oneformer''', '''OneFormerImageProcessor'''),
        ('''owlvit''', '''OwlViTImageProcessor'''),
        ('''perceiver''', '''PerceiverImageProcessor'''),
        ('''pix2struct''', '''Pix2StructImageProcessor'''),
        ('''poolformer''', '''PoolFormerImageProcessor'''),
        ('''regnet''', '''ConvNextImageProcessor'''),
        ('''resnet''', '''ConvNextImageProcessor'''),
        ('''sam''', '''SamImageProcessor'''),
        ('''segformer''', '''SegformerImageProcessor'''),
        ('''swiftformer''', '''ViTImageProcessor'''),
        ('''swin''', '''ViTImageProcessor'''),
        ('''swin2sr''', '''Swin2SRImageProcessor'''),
        ('''swinv2''', '''ViTImageProcessor'''),
        ('''table-transformer''', '''DetrImageProcessor'''),
        ('''timesformer''', '''VideoMAEImageProcessor'''),
        ('''tvlt''', '''TvltImageProcessor'''),
        ('''upernet''', '''SegformerImageProcessor'''),
        ('''van''', '''ConvNextImageProcessor'''),
        ('''videomae''', '''VideoMAEImageProcessor'''),
        ('''vilt''', '''ViltImageProcessor'''),
        ('''vit''', '''ViTImageProcessor'''),
        ('''vit_hybrid''', '''ViTHybridImageProcessor'''),
        ('''vit_mae''', '''ViTImageProcessor'''),
        ('''vit_msn''', '''ViTImageProcessor'''),
        ('''xclip''', '''CLIPImageProcessor'''),
        ('''yolos''', '''YolosImageProcessor'''),
    ]
)

snake_case__						:   Tuple			 = _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)


def    _snake_case  (  _snake_case :	str	):
      for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
            if class_name in extractors:
                  lowerCAmelCase    :		Union[str, Any]				=      model_type_to_module_name(_snake_case	)

                  lowerCAmelCase    :		List[Any]				=      importlib.import_module(f'''.{module_name}'''       ,      '''transformers.models'''	)
                  try:
                        return getattr(_snake_case       ,      _snake_case	)
                  except AttributeError:
                        continue

      for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
            if getattr(_snake_case       ,      '''__name__'''       ,      _snake_case	) == class_name:
                  return extractor

    # 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    :		Dict				=      importlib.import_module('''transformers'''	)
      if hasattr(_snake_case       ,      _snake_case	):
            return getattr(_snake_case       ,      _snake_case	)

      return None


def    _snake_case  (  _snake_case :	Union[str, os.PathLike]       ,      _snake_case :	Optional[Union[str, os.PathLike]] = None       ,      _snake_case :	bool = False       ,      _snake_case :	bool = False       ,      _snake_case :	Optional[Dict[str, str]] = None       ,      _snake_case :	Optional[Union[bool, str]] = None       ,      _snake_case :	Optional[str] = None       ,      _snake_case :	bool = False       ,      **_snake_case :	Tuple       ,      ):
      lowerCAmelCase    :		str				=      get_file_from_repo(
          _snake_case       ,      _snake_case       ,      cache_dir=_snake_case       ,      force_download=_snake_case       ,      resume_download=_snake_case       ,      proxies=_snake_case       ,      use_auth_token=_snake_case       ,      revision=_snake_case       ,      local_files_only=_snake_case       ,      )
      if resolved_config_file is None:
            logger.info(
                '''Could not locate the image processor configuration file, will try to use the model config instead.'''	)
            return {}

      with open(_snake_case       ,      encoding='''utf-8'''	) as reader:
            return json.load(_snake_case	)






class 						snake_case_:






     def __init__(		self     :    Any ):
           raise EnvironmentError(
               '''AutoImageProcessor is designed to be instantiated '''
               '''using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.''' )






     @classmethod
     @replace_list_option_in_docstrings(UpperCamelCase_ )
     def    lowerCamelCase__   (		cls     :    Union[str, Any]    , UpperCamelCase_     :    List[Any]    , **UpperCamelCase_     :    str ):
           lowerCAmelCase    :		Tuple				=      kwargs.pop('''config'''    , UpperCamelCase_ )
           lowerCAmelCase    :		Dict				=      kwargs.pop('''trust_remote_code'''    , UpperCamelCase_ )
           lowerCAmelCase    :		Optional[int]				=      True

           lowerCAmelCase,					lowerCAmelCase    :		Any				=      ImageProcessingMixin.get_image_processor_dict(UpperCamelCase_    , **UpperCamelCase_ )
           lowerCAmelCase    :		List[Any]				=      config_dict.get('''image_processor_type'''    , UpperCamelCase_ )
           lowerCAmelCase    :		Union[str, Any]				=      None
           if "AutoImageProcessor" in config_dict.get('''auto_map'''    , {} ):
                 lowerCAmelCase    :		str				=      config_dict['''auto_map''']['''AutoImageProcessor''']

           # If we still don't have the image processor class, check if we're loading from a previous feature extractor config
           # and if so, infer the image processor class from there.
           if image_processor_class is None and image_processor_auto_map is None:
                 lowerCAmelCase    :		Dict				=      config_dict.pop('''feature_extractor_type'''    , UpperCamelCase_ )
                 if feature_extractor_class is not None:
                       logger.warning(
                           '''Could not find image processor class in the image processor config or the model config. Loading'''
                           ''' based on pattern matching with the model\'s feature extractor configuration.''' )
                       lowerCAmelCase    :		int				=      feature_extractor_class.replace('''FeatureExtractor'''    , '''ImageProcessor''' )
                 if "AutoFeatureExtractor" in config_dict.get('''auto_map'''    , {} ):
                       lowerCAmelCase    :		Any				=      config_dict['''auto_map''']['''AutoFeatureExtractor''']
                       lowerCAmelCase    :		Any				=      feature_extractor_auto_map.replace('''FeatureExtractor'''    , '''ImageProcessor''' )
                       logger.warning(
                           '''Could not find image processor auto map in the image processor config or the model config.'''
                           ''' Loading based on pattern matching with the model\'s feature extractor configuration.''' )

        # If we don't find the image processor class in the image processor config, let's try the model config.
           if image_processor_class is None and image_processor_auto_map is None:
                 if not isinstance(UpperCamelCase_    , UpperCamelCase_ ):
                       lowerCAmelCase    :		List[str]				=      AutoConfig.from_pretrained(UpperCamelCase_    , **UpperCamelCase_ )
                 # It could be in `config.image_processor_type``
                 lowerCAmelCase    :		Dict				=      getattr(UpperCamelCase_    , '''image_processor_type'''    , UpperCamelCase_ )
                 if hasattr(UpperCamelCase_    , '''auto_map''' ) and "AutoImageProcessor" in config.auto_map:
                       lowerCAmelCase    :		List[Any]				=      config.auto_map['''AutoImageProcessor''']

           if image_processor_class is not None:
                 lowerCAmelCase    :		List[str]				=      image_processor_class_from_name(UpperCamelCase_ )

           lowerCAmelCase    :		int				=      image_processor_auto_map is not None
           lowerCAmelCase    :		List[str]				=      image_processor_class is not None or type(UpperCamelCase_ ) in IMAGE_PROCESSOR_MAPPING
           lowerCAmelCase    :		Tuple				=      resolve_trust_remote_code(
               UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_    , UpperCamelCase_ )

           if has_remote_code and trust_remote_code:
                 lowerCAmelCase    :		Any				=      get_class_from_dynamic_module(
                     UpperCamelCase_    , UpperCamelCase_    , **UpperCamelCase_ )
                 lowerCAmelCase    :		Dict				=      kwargs.pop('''code_revision'''    , UpperCamelCase_ )
                 if os.path.isdir(UpperCamelCase_ ):
                       image_processor_class.register_for_auto_class()
                 return image_processor_class.from_dict(UpperCamelCase_    , **UpperCamelCase_ )
           elif image_processor_class is not None:
                 return image_processor_class.from_dict(UpperCamelCase_    , **UpperCamelCase_ )
           # Last try: we use the IMAGE_PROCESSOR_MAPPING.
           elif type(UpperCamelCase_ ) in IMAGE_PROCESSOR_MAPPING:
                 lowerCAmelCase    :		int				=      IMAGE_PROCESSOR_MAPPING[type(UpperCamelCase_ )]
                 return image_processor_class.from_dict(UpperCamelCase_    , **UpperCamelCase_ )

           raise ValueError(
               F'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '''
               F'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '''
               F'''`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys() )}''' )






     @staticmethod
     def    lowerCamelCase__   (		UpperCamelCase_     :    Any    , UpperCamelCase_     :    Any ):
           IMAGE_PROCESSOR_MAPPING.register(UpperCamelCase_    , UpperCamelCase_ )






"""simple docstring"""





import unittest
from typing import Dict, List, Optional, Union

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 BridgeTowerImageProcessor



class 						snake_case_(				unittest.TestCase	):






     def __init__(		self     :    Union[str, Any]    , UpperCamelCase_     :    Optional[Any]    , UpperCamelCase_     :    bool = True    , UpperCamelCase_     :    Dict[str, int] = None    , UpperCamelCase_     :    int = 3_2    , UpperCamelCase_     :    bool = True    , UpperCamelCase_     :    Union[int, float] = 1 / 2_5_5    , UpperCamelCase_     :    bool = True    , UpperCamelCase_     :    bool = True    , UpperCamelCase_     :    Optional[Union[float, List[float]]] = [0.48_145_466, 0.4_578_275, 0.40_821_073]    , UpperCamelCase_     :    Optional[Union[float, List[float]]] = [0.26_862_954, 0.26_130_258, 0.27_577_711]    , UpperCamelCase_     :    bool = True    , UpperCamelCase_     :    Optional[int]=7    , UpperCamelCase_     :    int=3_0    , UpperCamelCase_     :    str=4_0_0    , UpperCamelCase_     :    List[Any]=3    , ):
           lowerCAmelCase    :		Union[str, Any]				=      parent
           lowerCAmelCase    :		Union[str, Any]				=      do_resize
           lowerCAmelCase    :		List[str]				=      size if size is not None else {'''shortest_edge''': 2_8_8}
           lowerCAmelCase    :		int				=      size_divisor
           lowerCAmelCase    :		List[str]				=      do_rescale
           lowerCAmelCase    :		Optional[Any]				=      rescale_factor
           lowerCAmelCase    :		Dict				=      do_normalize
           lowerCAmelCase    :		Any				=      do_center_crop
           lowerCAmelCase    :		Union[str, Any]				=      image_mean
           lowerCAmelCase    :		Optional[Any]				=      image_std
           lowerCAmelCase    :		Union[str, Any]				=      do_pad
           lowerCAmelCase    :		Union[str, Any]				=      batch_size
           lowerCAmelCase    :		Any				=      num_channels
           lowerCAmelCase    :		Union[str, Any]				=      min_resolution
           lowerCAmelCase    :		int				=      max_resolution






     def    lowerCamelCase__   (		self     :    Dict ):
           return {
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_normalize": self.do_normalize,
               "do_resize": self.do_resize,
               "size": self.size,
               "size_divisor": self.size_divisor,
           }






     def    lowerCamelCase__   (		self     :    Any    , UpperCamelCase_     :    int    , UpperCamelCase_     :    List[str]=False ):
           if not batched:
                 lowerCAmelCase    :		Dict				=      self.size['''shortest_edge''']
                 lowerCAmelCase    :		Dict				=      image_inputs[0]
                 if isinstance(UpperCamelCase_    , Image.Image ):
                       lowerCAmelCase,					lowerCAmelCase    :		Optional[int]				=      image.size
                 else:
                       lowerCAmelCase,					lowerCAmelCase    :		List[Any]				=      image.shape[1], image.shape[2]
                 lowerCAmelCase    :		Union[str, Any]				=      size / min(UpperCamelCase_    , UpperCamelCase_ )
                 if h < w:
                       lowerCAmelCase,					lowerCAmelCase    :		Dict				=      size, scale * w
                 else:
                       lowerCAmelCase,					lowerCAmelCase    :		Optional[int]				=      scale * h, size

                 lowerCAmelCase    :		List[Any]				=      int((1_3_3_3 / 8_0_0) * size )
                 if max(UpperCamelCase_    , UpperCamelCase_ ) > max_size:
                       lowerCAmelCase    :		int				=      max_size / max(UpperCamelCase_    , UpperCamelCase_ )
                       lowerCAmelCase    :		str				=      newh * scale
                       lowerCAmelCase    :		Tuple				=      neww * scale

                 lowerCAmelCase,					lowerCAmelCase    :		List[str]				=      int(newh + 0.5 ), int(neww + 0.5 )
                 lowerCAmelCase,					lowerCAmelCase    :		Tuple				=      (
                     newh // self.size_divisor * self.size_divisor,
                     neww // self.size_divisor * self.size_divisor,
                 )

           else:
                 lowerCAmelCase    :		Optional[int]				=      []
                 for image in image_inputs:
                       lowerCAmelCase,					lowerCAmelCase    :		List[str]				=      self.get_expected_values([image] )
                       expected_values.append((expected_height, expected_width) )
                 lowerCAmelCase    :		Union[str, Any]				=      max(UpperCamelCase_    , key=lambda UpperCamelCase_ : item[0] )[0]
                 lowerCAmelCase    :		Union[str, Any]				=      max(UpperCamelCase_    , key=lambda UpperCamelCase_ : item[1] )[1]

           return expected_height, expected_width



@require_torch
@require_vision
class 						snake_case_(				a__							,    unittest.TestCase	):
     __UpperCamelCase     =    BridgeTowerImageProcessor if is_vision_available() else None






     def    lowerCamelCase__   (		self     :    Optional[int] ):
           lowerCAmelCase    :		Optional[int]				=      BridgeTowerImageProcessingTester(self )






     @property
     def    lowerCamelCase__   (		self     :    List[str] ):
           return self.image_processor_tester.prepare_image_processor_dict()






     def    lowerCamelCase__   (		self     :    List[str] ):
           lowerCAmelCase    :		Optional[Any]				=      self.image_processing_class(**self.image_processor_dict )
           self.assertTrue(hasattr(UpperCamelCase_    , '''image_mean''' ) )
           self.assertTrue(hasattr(UpperCamelCase_    , '''image_std''' ) )
           self.assertTrue(hasattr(UpperCamelCase_    , '''do_normalize''' ) )
           self.assertTrue(hasattr(UpperCamelCase_    , '''do_resize''' ) )
           self.assertTrue(hasattr(UpperCamelCase_    , '''size''' ) )
           self.assertTrue(hasattr(UpperCamelCase_    , '''size_divisor''' ) )






     def    lowerCamelCase__   (		self     :    int ):
           pass






     def    lowerCamelCase__   (		self     :    Optional[Any] ):
           # Initialize image processor
           lowerCAmelCase    :		str				=      self.image_processing_class(**self.image_processor_dict )
           # create random PIL images
           lowerCAmelCase    :		Optional[int]				=      prepare_image_inputs(self.image_processor_tester    , equal_resolution=UpperCamelCase_ )
           for image in image_inputs:
                 self.assertIsInstance(UpperCamelCase_    , Image.Image )

           # Test not batched input
           lowerCAmelCase    :		Optional[int]				=      image_processing(image_inputs[0]    , return_tensors='''pt''' ).pixel_values

           lowerCAmelCase,					lowerCAmelCase    :		List[Any]				=      self.image_processor_tester.get_expected_values(UpperCamelCase_ )
           self.assertEqual(
               encoded_images.shape    , (1, self.image_processor_tester.num_channels, expected_height, expected_width)    , )

           # Test batched
           lowerCAmelCase    :		Dict				=      image_processing(UpperCamelCase_    , return_tensors='''pt''' ).pixel_values

           lowerCAmelCase,					lowerCAmelCase    :		int				=      self.image_processor_tester.get_expected_values(UpperCamelCase_    , batched=UpperCamelCase_ )
           self.assertEqual(
               encoded_images.shape    , (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )    , )






     def    lowerCamelCase__   (		self     :    Optional[Any] ):
           # Initialize image processor
           lowerCAmelCase    :		Tuple				=      self.image_processing_class(**self.image_processor_dict )
           # create random numpy tensors
           lowerCAmelCase    :		List[Any]				=      prepare_image_inputs(self.image_processor_tester    , equal_resolution=UpperCamelCase_    , numpify=UpperCamelCase_ )
           for image in image_inputs:
                 self.assertIsInstance(UpperCamelCase_    , np.ndarray )

           # Test not batched input
           lowerCAmelCase    :		Any				=      image_processing(image_inputs[0]    , return_tensors='''pt''' ).pixel_values

           lowerCAmelCase,					lowerCAmelCase    :		Optional[Any]				=      self.image_processor_tester.get_expected_values(UpperCamelCase_ )
           self.assertEqual(
               encoded_images.shape    , (1, self.image_processor_tester.num_channels, expected_height, expected_width)    , )

           # Test batched
           lowerCAmelCase    :		Tuple				=      image_processing(UpperCamelCase_    , return_tensors='''pt''' ).pixel_values

           lowerCAmelCase,					lowerCAmelCase    :		str				=      self.image_processor_tester.get_expected_values(UpperCamelCase_    , batched=UpperCamelCase_ )
           self.assertEqual(
               encoded_images.shape    , (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )    , )






     def    lowerCamelCase__   (		self     :    Optional[int] ):
           # Initialize image processor
           lowerCAmelCase    :		Union[str, Any]				=      self.image_processing_class(**self.image_processor_dict )
           # create random PyTorch tensors
           lowerCAmelCase    :		List[str]				=      prepare_image_inputs(self.image_processor_tester    , equal_resolution=UpperCamelCase_    , torchify=UpperCamelCase_ )
           for image in image_inputs:
                 self.assertIsInstance(UpperCamelCase_    , torch.Tensor )

           # Test not batched input
           lowerCAmelCase    :		Any				=      image_processing(image_inputs[0]    , return_tensors='''pt''' ).pixel_values

           lowerCAmelCase,					lowerCAmelCase    :		Tuple				=      self.image_processor_tester.get_expected_values(UpperCamelCase_ )
           self.assertEqual(
               encoded_images.shape    , (1, self.image_processor_tester.num_channels, expected_height, expected_width)    , )

           # Test batched
           lowerCAmelCase    :		str				=      image_processing(UpperCamelCase_    , return_tensors='''pt''' ).pixel_values

           lowerCAmelCase,					lowerCAmelCase    :		str				=      self.image_processor_tester.get_expected_values(UpperCamelCase_    , batched=UpperCamelCase_ )
           self.assertEqual(
               encoded_images.shape    , (
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   expected_height,
                   expected_width,
               )    , )


