




"""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,
)


_A													=      logging.get_logger(__name__)

_A													=      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"""),
    ]
)

_A													=      _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)



def 	lowercase_				(			__UpperCAmelCase				)						->    List[Any]:
      for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
            if class_name in extractors:
                  lowerCAmelCase__      :			str   =	model_type_to_module_name(__UpperCAmelCase				)

                  lowerCAmelCase__      :			List[str]   =	importlib.import_module(f""".{module_name}"""    ,		"""transformers.models"""				)
                  try:
                        return getattr(__UpperCAmelCase    ,		__UpperCAmelCase				)
                  except AttributeError:
                        continue

      for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
            if getattr(__UpperCAmelCase    ,		"""__name__"""    ,		__UpperCAmelCase				) == 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__      :			Union[str, Any]   =	importlib.import_module("""transformers"""				)
      if hasattr(__UpperCAmelCase    ,		__UpperCAmelCase				):
            return getattr(__UpperCAmelCase    ,		__UpperCAmelCase				)

      return None



def 	lowercase_				(			__UpperCAmelCase    ,		__UpperCAmelCase = None    ,		__UpperCAmelCase = False    ,		__UpperCAmelCase = False    ,		__UpperCAmelCase = None    ,		__UpperCAmelCase = None    ,		__UpperCAmelCase = None    ,		__UpperCAmelCase = False    ,		**__UpperCAmelCase    ,		)						->    Optional[Any]:
      lowerCAmelCase__      :			Union[str, Any]   =	get_file_from_repo(
          __UpperCAmelCase    ,		__UpperCAmelCase    ,		cache_dir=__UpperCAmelCase    ,		force_download=__UpperCAmelCase    ,		resume_download=__UpperCAmelCase    ,		proxies=__UpperCAmelCase    ,		use_auth_token=__UpperCAmelCase    ,		revision=__UpperCAmelCase    ,		local_files_only=__UpperCAmelCase    ,		)
      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(__UpperCAmelCase    ,		encoding="""utf-8"""				) as reader:
            return json.load(__UpperCAmelCase				)


class _lowerCamelCase    :






   def __init__(		self       :		Tuple   )			->						List[Any]:

         """simple docstring"""
         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       :		List[Any]   ,     UpperCamelCase       :		int   ,     **UpperCamelCase       :		Tuple   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	kwargs.pop("""config"""   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	kwargs.pop("""trust_remote_code"""   ,     UpperCamelCase   )
         lowerCAmelCase__      :			List[str]   =	True

         lowerCAmelCase__ ,   lowerCAmelCase__      :			int   =	ImageProcessingMixin.get_image_processor_dict(UpperCamelCase   ,     **UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	config_dict.get("""image_processor_type"""   ,     UpperCamelCase   )
         lowerCAmelCase__      :			Any   =	None
         if "AutoImageProcessor" in config_dict.get("""auto_map"""   ,     {}   ):
               lowerCAmelCase__      :			Optional[Any]   =	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__      :			Optional[Any]   =	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__      :			List[str]   =	feature_extractor_class.replace("""FeatureExtractor"""   ,     """ImageProcessor"""   )
               if "AutoFeatureExtractor" in config_dict.get("""auto_map"""   ,     {}   ):
                     lowerCAmelCase__      :			int   =	config_dict["""auto_map"""]["""AutoFeatureExtractor"""]
                     lowerCAmelCase__      :			Union[str, 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__      :			str   =	AutoConfig.from_pretrained(UpperCamelCase   ,     **UpperCamelCase   )
               # It could be in `config.image_processor_type``
               lowerCAmelCase__      :			Any   =	getattr(UpperCamelCase   ,     """image_processor_type"""   ,     UpperCamelCase   )
               if hasattr(UpperCamelCase   ,     """auto_map"""   ) and "AutoImageProcessor" in config.auto_map:
                     lowerCAmelCase__      :			Tuple   =	config.auto_map["""AutoImageProcessor"""]

         if image_processor_class is not None:
               lowerCAmelCase__      :			int   =	image_processor_class_from_name(UpperCamelCase   )

         lowerCAmelCase__      :			Dict   =	image_processor_auto_map is not None
         lowerCAmelCase__      :			Any   =	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__      :			Optional[int]   =	get_class_from_dynamic_module(
                   UpperCamelCase   ,     UpperCamelCase   ,     **UpperCamelCase   )
               lowerCAmelCase__      :			str   =	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       :		Optional[Any]   ,     UpperCamelCase       :		str   )			->						Union[str, Any]:

         """simple docstring"""
         IMAGE_PROCESSOR_MAPPING.register(UpperCamelCase   ,     UpperCamelCase   )











"""simple docstring"""


from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType


class _lowerCamelCase    (					a_						):
   _lowerCamelCase    :Dict     				=     ["image_processor", "tokenizer"]
   _lowerCamelCase    :Dict     				=     "BlipImageProcessor"
   _lowerCamelCase    :Any     				=     ("BertTokenizer", "BertTokenizerFast")






   def __init__(		self       :		Dict   ,     UpperCamelCase       :		Optional[int]   ,     UpperCamelCase       :		Union[str, Any]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[Any]   =	False
         super().__init__(UpperCamelCase   ,     UpperCamelCase   )
         lowerCAmelCase__      :			List[Any]   =	self.image_processor






   def __call__(		self       :		int   ,     UpperCamelCase       :		ImageInput = None   ,     UpperCamelCase       :		Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None   ,     UpperCamelCase       :		bool = True   ,     UpperCamelCase       :		Union[bool, str, PaddingStrategy] = False   ,     UpperCamelCase       :		Union[bool, str, TruncationStrategy] = None   ,     UpperCamelCase       :		Optional[int] = None   ,     UpperCamelCase       :		int = 0   ,     UpperCamelCase       :		Optional[int] = None   ,     UpperCamelCase       :		Optional[bool] = None   ,     UpperCamelCase       :		bool = False   ,     UpperCamelCase       :		bool = False   ,     UpperCamelCase       :		bool = False   ,     UpperCamelCase       :		bool = False   ,     UpperCamelCase       :		bool = False   ,     UpperCamelCase       :		bool = True   ,     UpperCamelCase       :		Optional[Union[str, TensorType]] = None   ,     **UpperCamelCase       :		Optional[int]   ,     )			->						BatchEncoding:

         """simple docstring"""
         if images is None and text is None:
               raise ValueError("""You have to specify either images or text."""   )

         # Get only text
         if images is None:
               lowerCAmelCase__      :			Any   =	self.tokenizer
               lowerCAmelCase__      :			Optional[int]   =	self.tokenizer(
                   text=UpperCamelCase   ,     add_special_tokens=UpperCamelCase   ,     padding=UpperCamelCase   ,     truncation=UpperCamelCase   ,     max_length=UpperCamelCase   ,     stride=UpperCamelCase   ,     pad_to_multiple_of=UpperCamelCase   ,     return_attention_mask=UpperCamelCase   ,     return_overflowing_tokens=UpperCamelCase   ,     return_special_tokens_mask=UpperCamelCase   ,     return_offsets_mapping=UpperCamelCase   ,     return_token_type_ids=UpperCamelCase   ,     return_length=UpperCamelCase   ,     verbose=UpperCamelCase   ,     return_tensors=UpperCamelCase   ,     **UpperCamelCase   ,     )
               return text_encoding

         # add pixel_values
         lowerCAmelCase__      :			Tuple   =	self.image_processor(UpperCamelCase   ,     return_tensors=UpperCamelCase   )

         if text is not None:
               lowerCAmelCase__      :			Optional[int]   =	self.tokenizer(
                   text=UpperCamelCase   ,     add_special_tokens=UpperCamelCase   ,     padding=UpperCamelCase   ,     truncation=UpperCamelCase   ,     max_length=UpperCamelCase   ,     stride=UpperCamelCase   ,     pad_to_multiple_of=UpperCamelCase   ,     return_attention_mask=UpperCamelCase   ,     return_overflowing_tokens=UpperCamelCase   ,     return_special_tokens_mask=UpperCamelCase   ,     return_offsets_mapping=UpperCamelCase   ,     return_token_type_ids=UpperCamelCase   ,     return_length=UpperCamelCase   ,     verbose=UpperCamelCase   ,     return_tensors=UpperCamelCase   ,     **UpperCamelCase   ,     )
         else:
               lowerCAmelCase__      :			Tuple   =	None

         if text_encoding is not None:
               encoding_image_processor.update(UpperCamelCase   )

         return encoding_image_processor






   def 	_lowerCAmelCase   (		self       :		int   ,     *UpperCamelCase       :		Union[str, Any]   ,     **UpperCamelCase       :		List[str]   )			->						Dict:

         """simple docstring"""
         return self.tokenizer.batch_decode(*UpperCamelCase   ,     **UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		List[Any]   ,     *UpperCamelCase       :		Tuple   ,     **UpperCamelCase       :		List[str]   )			->						List[Any]:

         """simple docstring"""
         return self.tokenizer.decode(*UpperCamelCase   ,     **UpperCamelCase   )






   @property
   def 	_lowerCAmelCase   (		self       :		List[Any]   )			->						Tuple:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	self.tokenizer.model_input_names
         lowerCAmelCase__      :			Union[str, Any]   =	self.image_processor.model_input_names
         return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names   )   )





