






'''simple docstring'''







import glob
import os
from typing import Dict, List, Union

import torch

from diffusers.utils import is_safetensors_available


if is_safetensors_available():
  import safetensors.torch

from huggingface_hub import snapshot_download

from diffusers import DiffusionPipeline, __version__
from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME




class      __SCREAMING_SNAKE_CASE					(UpperCamelCase__					):


  """simple docstring"""


  def __init__( self  ):






         """simple docstring"""


         self.register_to_config()
         super().__init__()







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         if dicta == dicta:
                return True
         else:
                a_	    = self._remove_meta_keys(lowerCAmelCase__  )
                a_	    = self._remove_meta_keys(lowerCAmelCase__  )
                if configa == configa:
                       print(f'Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.'  )
                       return True
         return False







  def       _a					( self      ,  UpperCamelCase__  ):






         """simple docstring"""


         a_	    = []
         a_	    = config_dict.copy()
         for key in config_dict.keys():
                if key.startswith('_'  ):
                       temp_dict.pop(lowerCAmelCase__  )
                       meta_keys.append(lowerCAmelCase__  )
         return (temp_dict, meta_keys)







  @torch.no_grad()
  def       _a					( self      ,  UpperCamelCase__      ,  **UpperCamelCase__  ):






         """simple docstring"""


         a_	    = kwargs.pop('cache_dir'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('resume_download'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('force_download'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('proxies'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('local_files_only'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('use_auth_token'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('revision'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('torch_dtype'      ,  lowerCAmelCase__  )
         a_	    = kwargs.pop('device_map'      ,  lowerCAmelCase__  )

         a_	    = kwargs.pop('alpha'      ,  0.5  )
         a_	    = kwargs.pop('interp'      ,  lowerCAmelCase__  )

         print('Received list'      ,  lowerCAmelCase__  )
         print(f'Combining with alpha={alpha}, interpolation mode={interp}'  )

         a_	    = len(lowerCAmelCase__  )
         # Ignore result from model_index_json comparision of the two checkpoints
         a_	    = kwargs.pop('force'      ,  lowerCAmelCase__  )

         # If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
         if checkpoint_count > 3 or checkpoint_count < 2:
                raise ValueError(
                    'Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being'
                    ' passed.'  )

         print('Received the right number of checkpoints'  )
         # chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
         # chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None

         # Validate that the checkpoints can be merged
         # Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
         a_	    = []
         for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
                a_	    = DiffusionPipeline.load_config(
                    lowerCAmelCase__      ,  cache_dir=lowerCAmelCase__      ,  resume_download=lowerCAmelCase__      ,  force_download=lowerCAmelCase__      ,  proxies=lowerCAmelCase__      ,  local_files_only=lowerCAmelCase__      ,  use_auth_token=lowerCAmelCase__      ,  revision=lowerCAmelCase__      ,  )
                config_dicts.append(lowerCAmelCase__  )

         a_	    = True
         for idx in range(1      ,  len(lowerCAmelCase__  )  ):
                comparison_result &= self._compare_model_configs(config_dicts[idx - 1]      ,  config_dicts[idx]  )
                if not force and comparison_result is False:
                       raise ValueError('Incompatible checkpoints. Please check model_index.json for the models.'  )
                       print(config_dicts[0]      ,  config_dicts[1]  )
         print('Compatible model_index.json files found'  )
         # Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
         a_	    = []
         for pretrained_model_name_or_path, config_dict in zip(lowerCAmelCase__      ,  lowerCAmelCase__  ):
                a_	    = [k for k in config_dict.keys() if not k.startswith('_'  )]
                a_	    = [os.path.join(lowerCAmelCase__      ,  '*'  ) for k in folder_names]
                allow_patterns += [
                    WEIGHTS_NAME,
                    SCHEDULER_CONFIG_NAME,
                    CONFIG_NAME,
                    ONNX_WEIGHTS_NAME,
                    DiffusionPipeline.config_name,
                ]
                a_	    = config_dict.get('_class_name'  )
                a_	    = {"diffusers": __version__, "pipeline_class": requested_pipeline_class}

                a_	    = (
                    pretrained_model_name_or_path
                    if os.path.isdir(lowerCAmelCase__  )
                    else snapshot_download(
                        lowerCAmelCase__      ,  cache_dir=lowerCAmelCase__      ,  resume_download=lowerCAmelCase__      ,  proxies=lowerCAmelCase__      ,  local_files_only=lowerCAmelCase__      ,  use_auth_token=lowerCAmelCase__      ,  revision=lowerCAmelCase__      ,  allow_patterns=lowerCAmelCase__      ,  user_agent=lowerCAmelCase__      ,  )
                )
                print('Cached Folder'      ,  lowerCAmelCase__  )
                cached_folders.append(lowerCAmelCase__  )

         # Step 3:-
         # Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
         a_	    = DiffusionPipeline.from_pretrained(
             cached_folders[0]      ,  torch_dtype=lowerCAmelCase__      ,  device_map=lowerCAmelCase__  )
         final_pipe.to(self.device  )

         a_	    = None
         if len(lowerCAmelCase__  ) > 2:
                a_	    = os.path.join(cached_folders[2]  )

         if interp == "sigmoid":
                a_	    = CheckpointMergerPipeline.sigmoid
         elif interp == "inv_sigmoid":
                a_	    = CheckpointMergerPipeline.inv_sigmoid
         elif interp == "add_diff":
                a_	    = CheckpointMergerPipeline.add_difference
         else:
                a_	    = CheckpointMergerPipeline.weighted_sum

         # Find each module's state dict.
         for attr in final_pipe.config.keys():
                if not attr.startswith('_'  ):
                       a_	    = os.path.join(cached_folders[1]      ,  lowerCAmelCase__  )
                       if os.path.exists(lowerCAmelCase__  ):
                              a_	    = [
                                  *glob.glob(os.path.join(lowerCAmelCase__      ,  '*.safetensors'  )  ),
                                  *glob.glob(os.path.join(lowerCAmelCase__      ,  '*.bin'  )  ),
                              ]
                              a_	    = files[0] if len(lowerCAmelCase__  ) > 0 else None
                       if len(lowerCAmelCase__  ) < 3:
                              a_	    = None
                       else:
                              a_	    = os.path.join(cached_folders[2]      ,  lowerCAmelCase__  )
                              if os.path.exists(lowerCAmelCase__  ):
                                     a_	    = [
                                         *glob.glob(os.path.join(lowerCAmelCase__      ,  '*.safetensors'  )  ),
                                         *glob.glob(os.path.join(lowerCAmelCase__      ,  '*.bin'  )  ),
                                     ]
                                     a_	    = files[0] if len(lowerCAmelCase__  ) > 0 else None
                                     # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                                     # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
                       if checkpoint_path_a is None and checkpoint_path_a is None:
                              print(f'Skipping {attr}: not present in 2nd or 3d model'  )
                              continue
                       try:
                              a_	    = getattr(lowerCAmelCase__      ,  lowerCAmelCase__  )
                              if isinstance(lowerCAmelCase__      ,  lowerCAmelCase__  ):  # ignore requires_safety_checker boolean
                                     continue
                              a_	    = getattr(lowerCAmelCase__      ,  'state_dict'  )
                              a_	    = theta_a()

                              a_	    = getattr(lowerCAmelCase__      ,  'load_state_dict'  )
                              a_	    = (
                                  safetensors.torch.load_file(lowerCAmelCase__  )
                                  if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'  ))
                                  else torch.load(lowerCAmelCase__      ,  map_location='cpu'  )
                              )
                              a_	    = None
                              if checkpoint_path_a:
                                     a_	    = (
                                         safetensors.torch.load_file(lowerCAmelCase__  )
                                         if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'  ))
                                         else torch.load(lowerCAmelCase__      ,  map_location='cpu'  )
                                     )

                              if not theta_a.keys() == theta_a.keys():
                                     print(f'Skipping {attr}: key mismatch'  )
                                     continue
                              if theta_a and not theta_a.keys() == theta_a.keys():
                                     print(f'Skipping {attr}:y mismatch'  )
                       except Exception as e:
                              print(f'Skipping {attr} do to an unexpected error: {str(lowerCAmelCase__  )}'  )
                              continue
                       print(f'MERGING {attr}'  )

                       for key in theta_a.keys():
                              if theta_a:
                                     a_	    = theta_func(theta_a[key]      ,  theta_a[key]      ,  theta_a[key]      ,  lowerCAmelCase__  )
                              else:
                                     a_	    = theta_func(theta_a[key]      ,  theta_a[key]      ,  lowerCAmelCase__      ,  lowerCAmelCase__  )

                       del theta_a
                       del theta_a
                       update_theta_a(lowerCAmelCase__  )

                       del theta_a
         return final_pipe







  @staticmethod
  def       _a					( UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         return ((1 - alpha) * thetaa) + (alpha * thetaa)







  @staticmethod
  def       _a					( UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         a_	    = alpha * alpha * (3 - (2 * alpha))
         return thetaa + ((thetaa - thetaa) * alpha)







  @staticmethod
  def       _a					( UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         import math

         a_	    = 0.5 - math.sin(math.asin(1.0 - 2.0 * alpha  ) / 3.0  )
         return thetaa + ((thetaa - thetaa) * alpha)







  @staticmethod
  def       _a					( UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         return thetaa + (thetaa - thetaa) * (1.0 - alpha)












'''simple docstring'''







import random
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():
  import PIL

  from transformers import FlavaImageProcessor
  from transformers.image_utils import PILImageResampling
  from transformers.models.flava.image_processing_flava import (
      FLAVA_CODEBOOK_MEAN,
      FLAVA_CODEBOOK_STD,
      FLAVA_IMAGE_MEAN,
      FLAVA_IMAGE_STD,
  )
else:
  __lowerCAmelCase					   =       __lowerCAmelCase					   =       __lowerCAmelCase					   =       __lowerCAmelCase					   =       None




class      __SCREAMING_SNAKE_CASE					(unittest.TestCase					):


  """simple docstring"""


  def __init__( self      ,  UpperCamelCase__      ,  UpperCamelCase__=7      ,  UpperCamelCase__=3      ,  UpperCamelCase__=30      ,  UpperCamelCase__=400      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=1 / 255      ,  UpperCamelCase__=True      ,  UpperCamelCase__=FLAVA_IMAGE_MEAN      ,  UpperCamelCase__=FLAVA_IMAGE_STD      ,  UpperCamelCase__=14      ,  UpperCamelCase__=75      ,  UpperCamelCase__=None      ,  UpperCamelCase__=16      ,  UpperCamelCase__=0.3      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=None      ,  UpperCamelCase__=True      ,  UpperCamelCase__=True      ,  UpperCamelCase__=FLAVA_CODEBOOK_MEAN      ,  UpperCamelCase__=FLAVA_CODEBOOK_STD      ,  ):






         """simple docstring"""


         a_	    = size if size is not None else {'height': 224, 'width': 224}
         a_	    = crop_size if crop_size is not None else {'height': 224, 'width': 224}
         a_	    = codebook_size if codebook_size is not None else {'height': 112, 'width': 112}
         a_	    = codebook_crop_size if codebook_crop_size is not None else {'height': 112, 'width': 112}

         a_	    = parent
         a_	    = batch_size
         a_	    = num_channels
         a_	    = do_resize
         a_	    = do_rescale
         a_	    = rescale_factor
         a_	    = min_resolution
         a_	    = max_resolution
         a_	    = size
         a_	    = resample if resample is not None else PILImageResampling.BICUBIC
         a_	    = do_normalize
         a_	    = image_mean
         a_	    = image_std
         a_	    = do_center_crop
         a_	    = crop_size

         a_	    = input_size_patches
         a_	    = total_mask_patches
         a_	    = mask_group_max_patches
         a_	    = mask_group_min_patches
         a_	    = mask_group_min_aspect_ratio
         a_	    = mask_group_max_aspect_ratio

         a_	    = codebook_do_resize
         a_	    = codebook_size
         a_	    = codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
         a_	    = codebook_do_center_crop
         a_	    = codebook_crop_size
         a_	    = codebook_do_map_pixels
         a_	    = codebook_do_normalize
         a_	    = codebook_image_mean
         a_	    = codebook_image_std







  def       _a					( self  ):






         """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,
             "resample": self.resample,
             "do_rescale": self.do_rescale,
             "rescale_factor": self.rescale_factor,
             "do_center_crop": self.do_center_crop,
             "crop_size": self.crop_size,
             "input_size_patches": self.input_size_patches,
             "total_mask_patches": self.total_mask_patches,
             "mask_group_max_patches": self.mask_group_max_patches,
             "mask_group_min_patches": self.mask_group_min_patches,
             "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
             "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
             "codebook_do_resize": self.codebook_do_resize,
             "codebook_size": self.codebook_size,
             "codebook_resample": self.codebook_resample,
             "codebook_do_center_crop": self.codebook_do_center_crop,
             "codebook_crop_size": self.codebook_crop_size,
             "codebook_do_map_pixels": self.codebook_do_map_pixels,
             "codebook_do_normalize": self.codebook_do_normalize,
             "codebook_image_mean": self.codebook_image_mean,
             "codebook_image_std": self.codebook_image_std,
         }







  def       _a					( self  ):






         """simple docstring"""


         return (self.size["height"], self.size["width"])







  def       _a					( self  ):






         """simple docstring"""


         return (
             (self.input_size_patches, self.input_size_patches)
             if not isinstance(self.input_size_patches      ,  UpperCamelCase__  )
             else self.input_size_patches
         )







  def       _a					( self  ):






         """simple docstring"""


         return (self.codebook_size["height"], self.codebook_size["width"])





@require_torch
@require_vision
class      __SCREAMING_SNAKE_CASE					(__A       ,					unittest.TestCase					):


  """simple docstring"""


  _a     :   Union[str, Any]			 =    FlavaImageProcessor if is_vision_available() else None
  _a     :   Dict			 =    None







  def       _a					( self  ):






         """simple docstring"""


         a_	    = FlavaImageProcessingTester(self  )







  @property
  def       _a					( self  ):






         """simple docstring"""


         return self.image_processor_tester.prepare_image_processor_dict()







  def       _a					( self  ):






         """simple docstring"""


         a_	    = 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__      ,  'resample'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'crop_size'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'do_center_crop'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'do_rescale'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'rescale_factor'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'masking_generator'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_do_resize'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_size'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_resample'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_do_center_crop'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_crop_size'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_do_map_pixels'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_do_normalize'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_image_mean'  )  )
         self.assertTrue(hasattr(UpperCamelCase__      ,  'codebook_image_std'  )  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.image_processing_class.from_dict(self.image_processor_dict  )
         self.assertEqual(image_processor.size      ,  {'height': 224, 'width': 224}  )
         self.assertEqual(image_processor.crop_size      ,  {'height': 224, 'width': 224}  )
         self.assertEqual(image_processor.codebook_size      ,  {'height': 112, 'width': 112}  )
         self.assertEqual(image_processor.codebook_crop_size      ,  {'height': 112, 'width': 112}  )

         a_	    = self.image_processing_class.from_dict(
             self.image_processor_dict      ,  size=42      ,  crop_size=84      ,  codebook_size=33      ,  codebook_crop_size=66  )
         self.assertEqual(image_processor.size      ,  {'height': 42, 'width': 42}  )
         self.assertEqual(image_processor.crop_size      ,  {'height': 84, 'width': 84}  )
         self.assertEqual(image_processor.codebook_size      ,  {'height': 33, 'width': 33}  )
         self.assertEqual(image_processor.codebook_crop_size      ,  {'height': 66, 'width': 66}  )







  def       _a					( self  ):






         """simple docstring"""


         pass







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.image_processing_class(**self.image_processor_dict  )
         # create random PIL images
         a_	    = prepare_image_inputs(self.image_processor_tester      ,  equal_resolution=UpperCamelCase__  )
         for image in image_inputs:
                self.assertIsInstance(UpperCamelCase__      ,  PIL.Image.Image  )

         # Test not batched input
         a_	    = image_processing(image_inputs[0]      ,  return_tensors='pt'  )

         # Test no bool masked pos
         self.assertFalse('bool_masked_pos' in encoded_images  )

         a_    ,  a_	    = self.image_processor_tester.get_expected_image_size()

         self.assertEqual(
             encoded_images.pixel_values.shape      ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)      ,  )

         # Test batched
         a_	    = image_processing(UpperCamelCase__      ,  return_tensors='pt'  )
         a_    ,  a_	    = self.image_processor_tester.get_expected_image_size()

         # Test no bool masked pos
         self.assertFalse('bool_masked_pos' in encoded_images  )

         self.assertEqual(
             encoded_images.pixel_values.shape      ,  (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )      ,  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         a_	    = self.image_processing_class(**self.image_processor_dict  )
         # create random tensors
         a_	    = prepare_image_inputs(self.image_processor_tester      ,  equal_resolution=UpperCamelCase__      ,  **UpperCamelCase__  )
         for image in image_inputs:
                self.assertIsInstance(UpperCamelCase__      ,  UpperCamelCase__  )

         # Test not batched input
         a_	    = image_processing(image_inputs[0]      ,  return_tensors='pt'  )

         a_    ,  a_	    = self.image_processor_tester.get_expected_image_size()
         self.assertEqual(
             encoded_images.pixel_values.shape      ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)      ,  )

         a_	    = image_processing(UpperCamelCase__      ,  return_image_mask=UpperCamelCase__      ,  return_tensors='pt'  )

         a_    ,  a_	    = self.image_processor_tester.get_expected_image_size()
         self.assertEqual(
             encoded_images.pixel_values.shape      ,  (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )      ,  )

         a_    ,  a_	    = self.image_processor_tester.get_expected_mask_size()
         self.assertEqual(
             encoded_images.bool_masked_pos.shape      ,  (
                 self.image_processor_tester.batch_size,
                 expected_height,
                 expected_width,
             )      ,  )

         # Test batched
         a_	    = image_processing(UpperCamelCase__      ,  return_tensors='pt'  ).pixel_values

         a_    ,  a_	    = self.image_processor_tester.get_expected_image_size()
         self.assertEqual(
             encoded_images.shape      ,  (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )      ,  )

         # Test masking
         a_	    = image_processing(UpperCamelCase__      ,  return_image_mask=UpperCamelCase__      ,  return_tensors='pt'  )

         a_    ,  a_	    = self.image_processor_tester.get_expected_image_size()
         self.assertEqual(
             encoded_images.pixel_values.shape      ,  (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )      ,  )

         a_    ,  a_	    = self.image_processor_tester.get_expected_mask_size()
         self.assertEqual(
             encoded_images.bool_masked_pos.shape      ,  (
                 self.image_processor_tester.batch_size,
                 expected_height,
                 expected_width,
             )      ,  )







  def       _a					( self  ):






         """simple docstring"""


         self._test_call_framework(np.ndarray      ,  prepare_kwargs={'numpify': True}  )







  def       _a					( self  ):






         """simple docstring"""


         self._test_call_framework(torch.Tensor      ,  prepare_kwargs={'torchify': True}  )







  def       _a					( self  ):






         """simple docstring"""


         random.seed(1_234  )
         a_	    = self.image_processing_class(**self.image_processor_dict  )
         a_	    = prepare_image_inputs(self.image_processor_tester      ,  equal_resolution=UpperCamelCase__      ,  torchify=UpperCamelCase__  )

         # Test not batched input
         a_	    = image_processing(image_inputs[0]      ,  return_image_mask=UpperCamelCase__      ,  return_tensors='pt'  )
         self.assertEqual(encoded_images.bool_masked_pos.sum().item()      ,  75  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.image_processing_class(**self.image_processor_dict  )
         # create random PIL images
         a_	    = prepare_image_inputs(self.image_processor_tester      ,  equal_resolution=UpperCamelCase__  )
         for image in image_inputs:
                self.assertIsInstance(UpperCamelCase__      ,  PIL.Image.Image  )

         # Test not batched input
         a_	    = image_processing(image_inputs[0]      ,  return_codebook_pixels=UpperCamelCase__      ,  return_tensors='pt'  )
         a_    ,  a_	    = self.image_processor_tester.get_expected_codebook_image_size()
         self.assertEqual(
             encoded_images.codebook_pixel_values.shape      ,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)      ,  )

         # Test batched
         a_	    = image_processing(UpperCamelCase__      ,  return_codebook_pixels=UpperCamelCase__      ,  return_tensors='pt'  )
         a_    ,  a_	    = self.image_processor_tester.get_expected_codebook_image_size()
         self.assertEqual(
             encoded_images.codebook_pixel_values.shape      ,  (
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 expected_height,
                 expected_width,
             )      ,  )




