


'''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__  :					Union[str, Any]        =       logging.get_logger(__name__)

a__  :					Any        =       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__  :					str        =       _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)







def _UpperCamelCase       (     __A    )							->		Dict:


      '''simple docstring'''



      for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
            if class_name in extractors:
                  UpperCamelCase__										=				model_type_to_module_name(lowerCAmelCase__    )

                  UpperCamelCase__										=				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.
      UpperCamelCase__										=				importlib.import_module("transformers"    )
      if hasattr(lowerCAmelCase__      ,			lowerCAmelCase__    ):
            return getattr(lowerCAmelCase__      ,			lowerCAmelCase__    )

      return None







def _UpperCamelCase       (     __A      ,			__A = None      ,			__A = False      ,			__A = False      ,			__A = None      ,			__A = None      ,			__A = None      ,			__A = False      ,			**__A      ,			)							->		str:


      '''simple docstring'''



      UpperCamelCase__										=				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 					lowercase_     :


    def __init__(     self    ):
          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  ,					a  ,					**a    ):
          UpperCamelCase__										=				kwargs.pop("config"  ,					__lowerCAmelCase    )
          UpperCamelCase__										=				kwargs.pop("trust_remote_code"  ,					__lowerCAmelCase    )
          UpperCamelCase__										=				True

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

          if image_processor_class is not None:
                UpperCamelCase__										=				image_processor_class_from_name(__lowerCAmelCase    )

          UpperCamelCase__										=				image_processor_auto_map is not None
          UpperCamelCase__										=				image_processor_class is not None or type(__lowerCAmelCase    ) in IMAGE_PROCESSOR_MAPPING
          UpperCamelCase__										=				resolve_trust_remote_code(
              __lowerCAmelCase  ,					__lowerCAmelCase  ,					__lowerCAmelCase  ,					__lowerCAmelCase    )

          if has_remote_code and trust_remote_code:
                UpperCamelCase__										=				get_class_from_dynamic_module(
                    __lowerCAmelCase  ,					__lowerCAmelCase  ,					**__lowerCAmelCase    )
                UpperCamelCase__										=				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:
                UpperCamelCase__										=				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							(     a  ,					a    ):
          IMAGE_PROCESSOR_MAPPING.register(__lowerCAmelCase  ,					__lowerCAmelCase    )






"""simple docstring"""






import numpy as np
import torch
from imwatermark import WatermarkEncoder


# Copied from https://github.com/Stability-AI/generative-models/blob/613af104c6b85184091d42d374fef420eddb356d/scripts/demo/streamlit_helpers.py#L66
__lowerCAmelCase    :       Union[str, Any]					     =0B1011_0011_1110_1100_1001_0000_0111_1011_1011_0001_1001_1110
# bin(x)[2:] gives bits of x as str, use int to convert them to 0/1
__lowerCAmelCase    :       Optional[int]					     =[int(bit) for bit in bin(WATERMARK_MESSAGE)[2:]]





class  _A						:

      def __init__(						self						):







            """simple docstring"""



            lowercase														=	WATERMARK_BITS
            lowercase														=	WatermarkEncoder()

            self.encoder.set_watermark("""bits"""		,       self.watermark						)







      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            if images.shape[-1] < 256:
                  return images

            lowercase														=	(255 * (images / 2 + 0.5)).cpu().permute(0		,       2		,       3		,       1						).float().numpy()

            lowercase														=	[self.encoder.encode(__lowerCAmelCase		,       """dwtDct"""						) for image in images]

            lowercase														=	torch.from_numpy(np.array(__lowerCAmelCase						)						).permute(0		,       3		,       1		,       2						)

            lowercase														=	torch.clamp(2 * (images / 255 - 0.5)		,       min=-1.0		,       max=1.0						)
            return images



