





import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)


def       UpperCamelCase__(			UpperCamelCase__     :			Tuple					,	UpperCamelCase__     :			List[str]					,	UpperCamelCase__     :			List[str]    )->Dict:
       if isinstance(UpperCamelCase__					,	torch.Tensor    ):
              return image
       elif isinstance(UpperCamelCase__					,	PIL.Image.Image    ):
              A__		   =		[image]

       if isinstance(image[0]					,	PIL.Image.Image    ):
              A__		   =		[np.array(i.resize((w, h)					,	resample=PIL_INTERPOLATION['''lanczos''']    )    )[None, :] for i in image]
              A__		   =		np.concatenate(UpperCamelCase__					,	axis=0    )
              A__		   =		np.array(UpperCamelCase__    ).astype(np.floataa    ) / 255.0
              A__		   =		image.transpose(0					,	3					,	1					,	2    )
              A__		   =		2.0 * image - 1.0
              A__		   =		torch.from_numpy(UpperCamelCase__    )
       elif isinstance(image[0]					,	torch.Tensor    ):
              A__		   =		torch.cat(UpperCamelCase__					,	dim=0    )
       return image


def       UpperCamelCase__(			UpperCamelCase__     :			List[Any]					,	UpperCamelCase__     :			Optional[int]					,	UpperCamelCase__     :			Tuple					,	UpperCamelCase__     :			Optional[Any]=0.9995    )->Optional[Any]:
       if not isinstance(UpperCamelCase__					,	np.ndarray    ):
              A__		   =		True
              A__		   =		va.device
              A__		   =		va.cpu().numpy()
              A__		   =		va.cpu().numpy()

       A__		   =		np.sum(va * va / (np.linalg.norm(UpperCamelCase__    ) * np.linalg.norm(UpperCamelCase__    ))    )
       if np.abs(UpperCamelCase__    ) > DOT_THRESHOLD:
              A__		   =		(1 - t) * va + t * va
       else:
              A__		   =		np.arccos(UpperCamelCase__    )
              A__		   =		np.sin(UpperCamelCase__    )
              A__		   =		theta_a * t
              A__		   =		np.sin(UpperCamelCase__    )
              A__		   =		np.sin(theta_a - theta_t    ) / sin_theta_a
              A__		   =		sin_theta_t / sin_theta_a
              A__		   =		sa * va + sa * va

       if inputs_are_torch:
              A__		   =		torch.from_numpy(UpperCamelCase__    ).to(UpperCamelCase__    )

       return va


def       UpperCamelCase__(			UpperCamelCase__     :			int					,	UpperCamelCase__     :			Any    )->Union[str, Any]:
       A__		   =		F.normalize(UpperCamelCase__					,	dim=-1    )
       A__		   =		F.normalize(UpperCamelCase__					,	dim=-1    )
       return (x - y).norm(dim=-1    ).div(2    ).arcsin().pow(2    ).mul(2    )


def       UpperCamelCase__(			UpperCamelCase__     :			Any					,	UpperCamelCase__     :			Tuple    )->Optional[int]:
       for param in model.parameters():
              A__		   =		value




class        SCREAMING_SNAKE_CASE__					(		UpperCamelCase__ ):



 def __init__(				self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase=None,__lowerCamelCase=None,__lowerCamelCase=None,):
        super().__init__()
        self.register_modules(
            vae=__lowerCamelCase,text_encoder=__lowerCamelCase,clip_model=__lowerCamelCase,tokenizer=__lowerCamelCase,unet=__lowerCamelCase,scheduler=__lowerCamelCase,feature_extractor=__lowerCamelCase,coca_model=__lowerCamelCase,coca_tokenizer=__lowerCamelCase,coca_transform=__lowerCamelCase,)
        A__		   =		(
            feature_extractor.size
            if isinstance(feature_extractor.size,__lowerCamelCase					)
            else feature_extractor.size['''shortest_edge''']
        )
        A__		   =		transforms.Normalize(mean=feature_extractor.image_mean,std=feature_extractor.image_std					)
        set_requires_grad(self.text_encoder,__lowerCamelCase					)
        set_requires_grad(self.clip_model,__lowerCamelCase					)



 def 							UpperCamelCase     (				self,__lowerCamelCase = "auto"					):
        if slice_size == "auto":
               # half the attention head size is usually a good trade-off between
               # speed and memory
               A__		   =		self.unet.config.attention_head_dim // 2
        self.unet.set_attention_slice(__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        self.enable_attention_slicing(__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        set_requires_grad(self.vae,__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        set_requires_grad(self.vae,__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        set_requires_grad(self.unet,__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        set_requires_grad(self.unet,__lowerCamelCase					)



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					):
        # get the original timestep using init_timestep
        A__		   =		min(int(num_inference_steps * strength					),__lowerCamelCase					)

        A__		   =		max(num_inference_steps - init_timestep,0					)
        A__		   =		self.scheduler.timesteps[t_start:]

        return timesteps, num_inference_steps - t_start



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase=None					):
        if not isinstance(__lowerCamelCase,torch.Tensor					):
               raise ValueError(f"`image` has to be of type `torch.Tensor` but is {type(__lowerCamelCase					)}"					)

        A__		   =		image.to(device=__lowerCamelCase,dtype=__lowerCamelCase					)

        if isinstance(__lowerCamelCase,__lowerCamelCase					):
               A__		   =		[
                   self.vae.encode(image[i : i + 1]					).latent_dist.sample(generator[i]					) for i in range(__lowerCamelCase					)
               ]
               A__		   =		torch.cat(__lowerCamelCase,dim=0					)
        else:
               A__		   =		self.vae.encode(__lowerCamelCase					).latent_dist.sample(__lowerCamelCase					)

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
        A__		   =		0.18215 * init_latents
        A__		   =		init_latents.repeat_interleave(__lowerCamelCase,dim=0					)

        A__		   =		randn_tensor(init_latents.shape,generator=__lowerCamelCase,device=__lowerCamelCase,dtype=__lowerCamelCase					)

        # get latents
        A__		   =		self.scheduler.add_noise(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)
        A__		   =		init_latents

        return latents



 def 							UpperCamelCase     (				self,__lowerCamelCase					):
        A__		   =		self.coca_transform(__lowerCamelCase					).unsqueeze(0					)
        with torch.no_grad(), torch.cuda.amp.autocast():
               A__		   =		self.coca_model.generate(transformed_image.to(device=self.device,dtype=self.coca_model.dtype					)					)
        A__		   =		self.coca_tokenizer.decode(generated[0].cpu().numpy()					)
        return generated.split('''<end_of_text>'''					)[0].replace('''<start_of_text>''',''''''					).rstrip(''' .,'''					)



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase					):
        A__		   =		self.feature_extractor.preprocess(__lowerCamelCase					)
        A__		   =		torch.from_numpy(clip_image_input['''pixel_values'''][0]					).unsqueeze(0					).to(self.device					).half()
        A__		   =		self.clip_model.get_image_features(__lowerCamelCase					)
        A__		   =		image_embeddings_clip / image_embeddings_clip.norm(p=2,dim=-1,keepdim=__lowerCamelCase					)
        A__		   =		image_embeddings_clip.repeat_interleave(__lowerCamelCase,dim=0					)
        return image_embeddings_clip



 @torch.enable_grad()
 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,):
        A__		   =		latents.detach().requires_grad_()

        A__		   =		self.scheduler.scale_model_input(__lowerCamelCase,__lowerCamelCase					)

        # predict the noise residual
        A__		   =		self.unet(__lowerCamelCase,__lowerCamelCase,encoder_hidden_states=__lowerCamelCase					).sample

        if isinstance(self.scheduler,(PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)					):
               A__		   =		self.scheduler.alphas_cumprod[timestep]
               A__		   =		1 - alpha_prod_t
               # compute predicted original sample from predicted noise also called
               # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
               A__		   =		(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

               A__		   =		torch.sqrt(__lowerCamelCase					)
               A__		   =		pred_original_sample * (fac) + latents * (1 - fac)
        elif isinstance(self.scheduler,__lowerCamelCase					):
               A__		   =		self.scheduler.sigmas[index]
               A__		   =		latents - sigma * noise_pred
        else:
               raise ValueError(f"scheduler type {type(self.scheduler					)} not supported"					)

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
        A__		   =		1 / 0.18215 * sample
        A__		   =		self.vae.decode(__lowerCamelCase					).sample
        A__		   =		(image / 2 + 0.5).clamp(0,1					)

        A__		   =		transforms.Resize(self.feature_extractor_size					)(__lowerCamelCase					)
        A__		   =		self.normalize(__lowerCamelCase					).to(latents.dtype					)

        A__		   =		self.clip_model.get_image_features(__lowerCamelCase					)
        A__		   =		image_embeddings_clip / image_embeddings_clip.norm(p=2,dim=-1,keepdim=__lowerCamelCase					)

        A__		   =		spherical_dist_loss(__lowerCamelCase,__lowerCamelCase					).mean() * clip_guidance_scale

        A__		   =		-torch.autograd.grad(__lowerCamelCase,__lowerCamelCase					)[0]

        if isinstance(self.scheduler,__lowerCamelCase					):
               A__		   =		latents.detach() + grads * (sigma**2)
               A__		   =		noise_pred_original
        else:
               A__		   =		noise_pred_original - torch.sqrt(__lowerCamelCase					) * grads
        return noise_pred, latents




 @torch.no_grad()
 def __call__(				self,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase = None,__lowerCamelCase = None,__lowerCamelCase = 512,__lowerCamelCase = 512,__lowerCamelCase = 0.6,__lowerCamelCase = 50,__lowerCamelCase = 7.5,__lowerCamelCase = 1,__lowerCamelCase = 0.0,__lowerCamelCase = 100,__lowerCamelCase = None,__lowerCamelCase = "pil",__lowerCamelCase = True,__lowerCamelCase = 0.8,__lowerCamelCase = 0.1,__lowerCamelCase = 0.1,):
        if isinstance(__lowerCamelCase,__lowerCamelCase					) and len(__lowerCamelCase					) != batch_size:
               raise ValueError(f"You have passed {batch_size} batch_size, but only {len(__lowerCamelCase					)} generators."					)

        if height % 8 != 0 or width % 8 != 0:
               raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}."					)

        if isinstance(__lowerCamelCase,torch.Generator					) and batch_size > 1:
               A__		   =		[generator] + [None] * (batch_size - 1)

        A__		   =		[
            ('''model''', self.coca_model is None),
            ('''tokenizer''', self.coca_tokenizer is None),
            ('''transform''', self.coca_transform is None),
        ]
        A__		   =		[x[0] for x in coca_is_none if x[1]]
        A__		   =		''', '''.join(__lowerCamelCase					)
        # generate prompts with coca model if prompt is None
        if content_prompt is None:
               if len(__lowerCamelCase					):
                      raise ValueError(
                          f"Content prompt is None and CoCa [{coca_is_none_str}] is None."
                          f"Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."					)
               A__		   =		self.get_image_description(__lowerCamelCase					)
        if style_prompt is None:
               if len(__lowerCamelCase					):
                      raise ValueError(
                          f"Style prompt is None and CoCa [{coca_is_none_str}] is None."
                          f" Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."					)
               A__		   =		self.get_image_description(__lowerCamelCase					)

        # get prompt text embeddings for content and style
        A__		   =		self.tokenizer(
            __lowerCamelCase,padding='''max_length''',max_length=self.tokenizer.model_max_length,truncation=__lowerCamelCase,return_tensors='''pt''',)
        A__		   =		self.text_encoder(content_text_input.input_ids.to(self.device					)					)[0]

        A__		   =		self.tokenizer(
            __lowerCamelCase,padding='''max_length''',max_length=self.tokenizer.model_max_length,truncation=__lowerCamelCase,return_tensors='''pt''',)
        A__		   =		self.text_encoder(style_text_input.input_ids.to(self.device					)					)[0]

        A__		   =		slerp(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)

        # duplicate text embeddings for each generation per prompt
        A__		   =		text_embeddings.repeat_interleave(__lowerCamelCase,dim=0					)

        # set timesteps
        A__		   =		'''offset''' in set(inspect.signature(self.scheduler.set_timesteps					).parameters.keys()					)
        A__		   =		{}
        if accepts_offset:
               A__		   =		1

        self.scheduler.set_timesteps(__lowerCamelCase,**__lowerCamelCase					)
        # Some schedulers like PNDM have timesteps as arrays
        # It's more optimized to move all timesteps to correct device beforehand
        self.scheduler.timesteps.to(self.device					)

        A__   ,      A__		   =		self.get_timesteps(__lowerCamelCase,__lowerCamelCase,self.device					)
        A__		   =		timesteps[:1].repeat(__lowerCamelCase					)

        # Preprocess image
        A__		   =		preprocess(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)
        A__		   =		self.prepare_latents(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,text_embeddings.dtype,self.device,__lowerCamelCase					)

        A__		   =		preprocess(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)
        A__		   =		self.prepare_latents(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,text_embeddings.dtype,self.device,__lowerCamelCase					)

        A__		   =		slerp(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)

        if clip_guidance_scale > 0:
               A__		   =		self.get_clip_image_embeddings(__lowerCamelCase,__lowerCamelCase					)
               A__		   =		self.get_clip_image_embeddings(__lowerCamelCase,__lowerCamelCase					)
               A__		   =		slerp(
                   __lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)

        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
        # corresponds to doing no classifier free guidance.
        A__		   =		guidance_scale > 1.0
        # get unconditional embeddings for classifier free guidance
        if do_classifier_free_guidance:
               A__		   =		content_text_input.input_ids.shape[-1]
               A__		   =		self.tokenizer([''''''],padding='''max_length''',max_length=__lowerCamelCase,return_tensors='''pt'''					)
               A__		   =		self.text_encoder(uncond_input.input_ids.to(self.device					)					)[0]
               # duplicate unconditional embeddings for each generation per prompt
               A__		   =		uncond_embeddings.repeat_interleave(__lowerCamelCase,dim=0					)

               # For classifier free guidance, we need to do two forward passes.
               # Here we concatenate the unconditional and text embeddings into a single batch
               # to avoid doing two forward passes
               A__		   =		torch.cat([uncond_embeddings, text_embeddings]					)

        # get the initial random noise unless the user supplied it

        # Unlike in other pipelines, latents need to be generated in the target device
        # for 1-to-1 results reproducibility with the CompVis implementation.
        # However this currently doesn't work in `mps`.
        A__		   =		(batch_size, self.unet.config.in_channels, height // 8, width // 8)
        A__		   =		text_embeddings.dtype
        if latents is None:
               if self.device.type == "mps":
                      # randn does not work reproducibly on mps
                      A__		   =		torch.randn(__lowerCamelCase,generator=__lowerCamelCase,device='''cpu''',dtype=__lowerCamelCase					).to(
                          self.device					)
               else:
                      A__		   =		torch.randn(__lowerCamelCase,generator=__lowerCamelCase,device=self.device,dtype=__lowerCamelCase					)
        else:
               if latents.shape != latents_shape:
                      raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}"					)
               A__		   =		latents.to(self.device					)

        # scale the initial noise by the standard deviation required by the scheduler
        A__		   =		latents * self.scheduler.init_noise_sigma

        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
        # and should be between [0, 1]
        A__		   =		'''eta''' in set(inspect.signature(self.scheduler.step					).parameters.keys()					)
        A__		   =		{}
        if accepts_eta:
               A__		   =		eta

        # check if the scheduler accepts generator
        A__		   =		'''generator''' in set(inspect.signature(self.scheduler.step					).parameters.keys()					)
        if accepts_generator:
               A__		   =		generator

        with self.progress_bar(total=__lowerCamelCase					):
               for i, t in enumerate(__lowerCamelCase					):
                      # expand the latents if we are doing classifier free guidance
                      A__		   =		torch.cat([latents] * 2					) if do_classifier_free_guidance else latents
                      A__		   =		self.scheduler.scale_model_input(__lowerCamelCase,__lowerCamelCase					)

                      # predict the noise residual
                      A__		   =		self.unet(__lowerCamelCase,__lowerCamelCase,encoder_hidden_states=__lowerCamelCase					).sample

                      # perform classifier free guidance
                      if do_classifier_free_guidance:
                             A__   ,      A__		   =		noise_pred.chunk(2					)
                             A__		   =		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                      # perform clip guidance
                      if clip_guidance_scale > 0:
                             A__		   =		(
                                 text_embeddings.chunk(2					)[1] if do_classifier_free_guidance else text_embeddings
                             )
                             A__   ,      A__		   =		self.cond_fn(
                                 __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,)

                      # compute the previous noisy sample x_t -> x_t-1
                      A__		   =		self.scheduler.step(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,**__lowerCamelCase					).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
        A__		   =		1 / 0.18215 * latents
        A__		   =		self.vae.decode(__lowerCamelCase					).sample

        A__		   =		(image / 2 + 0.5).clamp(0,1					)
        A__		   =		image.cpu().permute(0,2,3,1					).numpy()

        if output_type == "pil":
               A__		   =		self.numpy_to_pil(__lowerCamelCase					)

        if not return_dict:
               return (image, None)

        return StableDiffusionPipelineOutput(images=__lowerCamelCase,nsfw_content_detected=__lowerCamelCase					)












import shutil
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_tf_cross_test,
    require_tf,
    require_torch,
    require_torchvision,
    require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import AutoProcessor, SamImageProcessor, SamProcessor

if is_torch_available():
       import torch

if is_tf_available():
       import tensorflow as tf




@require_vision
@require_torchvision
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



 def 							UpperCamelCase     (				self					):
        A__		   =		[np.random.randint(255,size=(3, 30, 400),dtype=np.uinta					)]

        A__		   =		[Image.fromarray(np.moveaxis(__lowerCamelCase,0,-1					)					) for x in image_inputs]

        return image_inputs



 def 							UpperCamelCase     (				self					):
        A__		   =		SamProcessor(image_processor=self.get_image_processor()					)
        processor.save_pretrained(self.tmpdirname					)

        A__		   =		self.get_image_processor(do_normalize=__lowerCamelCase,padding_value=1.0					)

        A__		   =		SamProcessor.from_pretrained(self.tmpdirname,do_normalize=__lowerCamelCase,padding_value=1.0					)

        self.assertEqual(processor.image_processor.to_json_string(),image_processor_add_kwargs.to_json_string()					)
        self.assertIsInstance(processor.image_processor,__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''np'''					)
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''np'''					)

        input_feat_extract.pop('''original_sizes'''					)  # pop original_sizes as it is popped in the processor
        input_feat_extract.pop('''reshaped_input_sizes'''					)  # pop original_sizes as it is popped in the processor

        for key in input_feat_extract.keys():
               self.assertAlmostEqual(input_feat_extract[key].sum(),input_processor[key].sum(),delta=1E-2					)




 @require_torch
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		[torch.ones((1, 3, 5, 5)					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		processor.post_process_masks(
            __lowerCamelCase,torch.tensor(__lowerCamelCase					),torch.tensor(__lowerCamelCase					)					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        # should also work with np
        A__		   =		[np.ones((1, 3, 5, 5)					)]
        A__		   =		processor.post_process_masks(__lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					)					)

        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		[[1, 0], [0, 1]]
        with self.assertRaises(__lowerCamelCase					):
               A__		   =		processor.post_process_masks(__lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					)					)




@require_vision
@require_tf
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



 def 							UpperCamelCase     (				self					):
        A__		   =		[np.random.randint(255,size=(3, 30, 400),dtype=np.uinta					)]

        A__		   =		[Image.fromarray(np.moveaxis(__lowerCamelCase,0,-1					)					) for x in image_inputs]

        return image_inputs



 def 							UpperCamelCase     (				self					):
        A__		   =		SamProcessor(image_processor=self.get_image_processor()					)
        processor.save_pretrained(self.tmpdirname					)

        A__		   =		self.get_image_processor(do_normalize=__lowerCamelCase,padding_value=1.0					)

        A__		   =		SamProcessor.from_pretrained(self.tmpdirname,do_normalize=__lowerCamelCase,padding_value=1.0					)

        self.assertEqual(processor.image_processor.to_json_string(),image_processor_add_kwargs.to_json_string()					)
        self.assertIsInstance(processor.image_processor,__lowerCamelCase					)



 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''np'''					)
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''np'''					)

        input_feat_extract.pop('''original_sizes'''					)  # pop original_sizes as it is popped in the processor
        input_feat_extract.pop('''reshaped_input_sizes'''					)  # pop reshaped_input_sizes as it is popped in the processor

        for key in input_feat_extract.keys():
               self.assertAlmostEqual(input_feat_extract[key].sum(),input_processor[key].sum(),delta=1E-2					)




 @require_tf
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		[tf.ones((1, 3, 5, 5)					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''tf'''					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		processor.post_process_masks(
            __lowerCamelCase,tf.convert_to_tensor(__lowerCamelCase					),tf.convert_to_tensor(__lowerCamelCase					),return_tensors='''tf''',)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        # should also work with np
        A__		   =		[np.ones((1, 3, 5, 5)					)]
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					),return_tensors='''tf'''					)

        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		[[1, 0], [0, 1]]
        with self.assertRaises(tf.errors.InvalidArgumentError					):
               A__		   =		processor.post_process_masks(
                   __lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					),return_tensors='''tf'''					)




@require_vision
@require_torchvision
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



 def 							UpperCamelCase     (				self					):
        A__		   =		[np.random.randint(255,size=(3, 30, 400),dtype=np.uinta					)]

        A__		   =		[Image.fromarray(np.moveaxis(__lowerCamelCase,0,-1					)					) for x in image_inputs]

        return image_inputs



 @is_pt_tf_cross_test
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		np.random.randint(0,2,size=(1, 3, 5, 5)					).astype(np.floataa					)
        A__		   =		[tf.convert_to_tensor(__lowerCamelCase					)]
        A__		   =		[torch.tensor(__lowerCamelCase					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''tf'''					)
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''pt'''					)

        self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy()					)					)




 @is_pt_tf_cross_test
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''pt'''					)['''pixel_values'''].numpy()
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''pt'''					)['''pixel_values'''].numpy()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''tf'''					)['''pixel_values'''].numpy()
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''tf'''					)['''pixel_values'''].numpy()

        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase					)					)
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase					)					)
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase					)					)





