




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


__magic_name__  :  Optional[Any]					=       logging.get_logger(__name__)

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

__magic_name__  :  str					=       _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def 		a_							( __lowerCAmelCase				):
  for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
    if class_name in extractors:
      lowerCAmelCase__										=      model_type_to_module_name(__lowerCAmelCase				)

      lowerCAmelCase__										=      importlib.import_module(F""".{module_name}"""   , '''transformers.models'''				)
      try:
        return getattr(__lowerCAmelCase   , __lowerCAmelCase				)
      except AttributeError:
        continue

  for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
    if getattr(__lowerCAmelCase   , '''__name__'''   , __lowerCAmelCase				) == 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__										=      importlib.import_module('''transformers'''				)
  if hasattr(__lowerCAmelCase   , __lowerCAmelCase				):
    return getattr(__lowerCAmelCase   , __lowerCAmelCase				)

  return None
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase = None   , __lowerCAmelCase = False   , __lowerCAmelCase = False   , __lowerCAmelCase = None   , __lowerCAmelCase = None   , __lowerCAmelCase = None   , __lowerCAmelCase = False   , **__lowerCAmelCase   , ):
  lowerCAmelCase__										=      get_file_from_repo(
      __lowerCAmelCase   , __lowerCAmelCase   , cache_dir=__lowerCAmelCase   , force_download=__lowerCAmelCase   , resume_download=__lowerCAmelCase   , proxies=__lowerCAmelCase   , use_auth_token=__lowerCAmelCase   , revision=__lowerCAmelCase   , local_files_only=__lowerCAmelCase   , )
  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(__lowerCAmelCase   , encoding='''utf-8'''				) as reader:
    return json.load(__lowerCAmelCase				)





class     SCREAMING_SNAKE_CASE__		:
     def __init__(						self	:		Dict						):



       """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(__lowerCamelCase						)
     def        A__      (						cls	:		Union[str, Any]       ,						__lowerCamelCase	:		Any       ,						**__lowerCamelCase	:		int						):



       """simple docstring"""
       lowerCAmelCase__										=      kwargs.pop('''config'''       ,						__lowerCamelCase						)
       lowerCAmelCase__										=      kwargs.pop('''trust_remote_code'''       ,						__lowerCamelCase						)
       lowerCAmelCase__										=      True

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

       if image_processor_class is not None:
         lowerCAmelCase__										=      image_processor_class_from_name(__lowerCamelCase						)

       lowerCAmelCase__										=      image_processor_auto_map is not None
       lowerCAmelCase__										=      image_processor_class is not None or type(__lowerCamelCase						) in IMAGE_PROCESSOR_MAPPING
       lowerCAmelCase__										=      resolve_trust_remote_code(
           __lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase						)

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

       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        A__      (						__lowerCamelCase	:		Dict       ,						__lowerCamelCase	:		Dict						):



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







import hashlib
import unittest
from typing import Dict

import numpy as np

from transformers import (
    MODEL_FOR_MASK_GENERATION_MAPPING,
    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
    is_vision_available,
    pipeline,
)
from transformers.pipelines import MaskGenerationPipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)


if is_vision_available():
      from PIL import Image
else:





      class     SCREAMING_SNAKE_CASE__		:
           @staticmethod
           def        A__      (						*__lowerCamelCase	:		List[str]       ,						**__lowerCamelCase	:		Optional[int]						):



             """simple docstring"""
             pass
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      hashlib.mda(image.tobytes()				)
  return m.hexdigest()[:10]
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      np.array(__lowerCAmelCase				)
  lowerCAmelCase__										=      npimg.shape
  return {"hash": hashimage(__lowerCAmelCase				), "shape": shape}





@is_pipeline_test
@require_vision
@require_torch
class     SCREAMING_SNAKE_CASE__		(unittest.TestCase			):
     lowercase_ :      Any				= dict(
         (list(MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if MODEL_FOR_MASK_GENERATION_MAPPING else [])			)
     lowercase_ :      str				= dict(
         (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else [])			)
     def        A__      (						self	:		int       ,						__lowerCamelCase	:		Union[str, Any]       ,						__lowerCamelCase	:		Dict       ,						__lowerCamelCase	:		int						):



       """simple docstring"""
       lowerCAmelCase__										=      MaskGenerationPipeline(model=__lowerCamelCase       ,						image_processor=__lowerCamelCase						)
       return image_segmenter, [
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
       ]
     def        A__      (						self	:		Optional[int]       ,						__lowerCamelCase	:		Dict       ,						__lowerCamelCase	:		Optional[int]						):



       """simple docstring"""
       pass
     @require_tf
     @unittest.skip('''Image segmentation not implemented in TF'''						)
     def        A__      (						self	:		Dict						):



       """simple docstring"""
       pass
     @slow
     @require_torch
     def        A__      (						self	:		Optional[int]						):



       """simple docstring"""
       lowerCAmelCase__										=      pipeline('''mask-generation'''       ,						model='''facebook/sam-vit-huge'''						)

       lowerCAmelCase__										=      image_segmenter('''http://images.cocodataset.org/val2017/000000039769.jpg'''       ,						points_per_batch=2_56						)

       # Shortening by hashing
       lowerCAmelCase__										=      []
       for i, o in enumerate(outputs['''masks''']						):
         new_outupt += [{"mask": mask_to_test_readable(__lowerCamelCase						), "scores": outputs["scores"][i]}]

       # fmt: off
       self.assertEqual(
           nested_simplify(__lowerCamelCase       ,						decimals=4						)       ,						[
               {'''mask''': {'''hash''': '''115ad19f5f''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0444},
               {'''mask''': {'''hash''': '''6affa964c6''', '''shape''': (4_80, 6_40)}, '''scores''': 1.021},
               {'''mask''': {'''hash''': '''dfe28a0388''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0167},
               {'''mask''': {'''hash''': '''c0a5f4a318''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0132},
               {'''mask''': {'''hash''': '''fe8065c197''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0053},
               {'''mask''': {'''hash''': '''e2d0b7a0b7''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9967},
               {'''mask''': {'''hash''': '''453c7844bd''', '''shape''': (4_80, 6_40)}, '''scores''': 0.993},
               {'''mask''': {'''hash''': '''3d44f2926d''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9909},
               {'''mask''': {'''hash''': '''64033ddc3f''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9879},
               {'''mask''': {'''hash''': '''801064ff79''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9834},
               {'''mask''': {'''hash''': '''6172f276ef''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9716},
               {'''mask''': {'''hash''': '''b49e60e084''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9612},
               {'''mask''': {'''hash''': '''a811e775fd''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9599},
               {'''mask''': {'''hash''': '''a6a8ebcf4b''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9552},
               {'''mask''': {'''hash''': '''9d8257e080''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9532},
               {'''mask''': {'''hash''': '''32de6454a8''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9516},
               {'''mask''': {'''hash''': '''af3d4af2c8''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9499},
               {'''mask''': {'''hash''': '''3c6db475fb''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9483},
               {'''mask''': {'''hash''': '''c290813fb9''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9464},
               {'''mask''': {'''hash''': '''b6f0b8f606''', '''shape''': (4_80, 6_40)}, '''scores''': 0.943},
               {'''mask''': {'''hash''': '''92ce16bfdf''', '''shape''': (4_80, 6_40)}, '''scores''': 0.943},
               {'''mask''': {'''hash''': '''c749b25868''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9408},
               {'''mask''': {'''hash''': '''efb6cab859''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9335},
               {'''mask''': {'''hash''': '''1ff2eafb30''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9326},
               {'''mask''': {'''hash''': '''788b798e24''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9262},
               {'''mask''': {'''hash''': '''abea804f0e''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8999},
               {'''mask''': {'''hash''': '''7b9e8ddb73''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8986},
               {'''mask''': {'''hash''': '''cd24047c8a''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8984},
               {'''mask''': {'''hash''': '''6943e6bcbd''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8873},
               {'''mask''': {'''hash''': '''b5f47c9191''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8871}
           ]       ,						)
       # fmt: on



     @require_torch
     @slow
     def        A__      (						self	:		Optional[int]						):



       """simple docstring"""
       lowerCAmelCase__										=      '''facebook/sam-vit-huge'''
       lowerCAmelCase__										=      pipeline('''mask-generation'''       ,						model=__lowerCamelCase						)

       lowerCAmelCase__										=      image_segmenter(
           '''http://images.cocodataset.org/val2017/000000039769.jpg'''       ,						pred_iou_thresh=1       ,						points_per_batch=2_56						)

       # Shortening by hashing
       lowerCAmelCase__										=      []
       for i, o in enumerate(outputs['''masks''']						):
         new_outupt += [{"mask": mask_to_test_readable(__lowerCamelCase						), "scores": outputs["scores"][i]}]

       self.assertEqual(
           nested_simplify(__lowerCamelCase       ,						decimals=4						)       ,						[
               {'''mask''': {'''hash''': '''115ad19f5f''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0444},
               {'''mask''': {'''hash''': '''6affa964c6''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0210},
               {'''mask''': {'''hash''': '''dfe28a0388''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0167},
               {'''mask''': {'''hash''': '''c0a5f4a318''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0132},
               {'''mask''': {'''hash''': '''fe8065c197''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0053},
           ]       ,						)

