


import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


__snake_case            =   logging.get_logger(__name__)  # pylint: disable=invalid-name




class    UpperCAmelCase					(       __snake_case    ):




			def __init__(						self							:		str       ,       __magic_name__							:		AutoencoderKL       ,       __magic_name__							:		CLIPTextModel       ,       __magic_name__							:		CLIPTokenizer       ,       __magic_name__							:		UNetaDConditionModel       ,       __magic_name__							:		Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]       ,       __magic_name__							:		StableDiffusionSafetyChecker       ,       __magic_name__							:		CLIPImageProcessor       ,       ):







						"""simple docstring"""







						super().__init__()
						self.register_modules(
						    vae=__magic_name__       ,       text_encoder=__magic_name__       ,       tokenizer=__magic_name__       ,       unet=__magic_name__       ,       scheduler=__magic_name__       ,       safety_checker=__magic_name__       ,       feature_extractor=__magic_name__       ,       )




			def   lowerCamelCase_					(						self							:		Dict       ,       __magic_name__							:		Optional[Union[str, int]] = "auto"						):







						"""simple docstring"""







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




			def   lowerCamelCase_					(						self							:		str						):







						"""simple docstring"""







						self.enable_attention_slicing(__magic_name__						)





			@torch.no_grad()
			def __call__(						self							:		Dict       ,       __magic_name__							:		Union[str, List[str]]       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_0       ,       __magic_name__							:		float = 7.5       ,       __magic_name__							:		Optional[Union[str, List[str]]] = None       ,       __magic_name__							:		Optional[int] = 1       ,       __magic_name__							:		float = 0.0       ,       __magic_name__							:		Optional[torch.Generator] = None       ,       __magic_name__							:		Optional[torch.FloatTensor] = None       ,       __magic_name__							:		Optional[str] = "pil"       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,       __magic_name__							:		int = 1       ,       __magic_name__							:		Optional[torch.FloatTensor] = None       ,       **__magic_name__							:		Optional[int]       ,       ):







						"""simple docstring"""







						if isinstance(__magic_name__       ,       __magic_name__						):
									UpperCamelCase         =					1
						elif isinstance(__magic_name__       ,       __magic_name__						):
									UpperCamelCase         =					len(__magic_name__						)
						else:
									raise ValueError(F'`prompt` has to be of type `str` or `list` but is {type(__magic_name__						)}'						)

						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 (callback_steps is None) or (
						    callback_steps is not None and (not isinstance(__magic_name__       ,       __magic_name__						) or callback_steps <= 0)
						):
									raise ValueError(
									    F'`callback_steps` has to be a positive integer but is {callback_steps} of type'
									    F' {type(__magic_name__						)}.'						)

						# get prompt text embeddings
						UpperCamelCase         =					self.tokenizer(
						    __magic_name__       ,       padding="""max_length"""       ,       max_length=self.tokenizer.model_max_length       ,       return_tensors="""pt"""       ,       )
						UpperCamelCase         =					text_inputs.input_ids

						if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
									UpperCamelCase         =					self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]						)
									logger.warning(
									    """The following part of your input was truncated because CLIP can only handle sequences up to"""
									    F' {self.tokenizer.model_max_length} tokens: {removed_text}'						)
									UpperCamelCase         =					text_input_ids[:, : self.tokenizer.model_max_length]

						if text_embeddings is None:
									UpperCamelCase         =					self.text_encoder(text_input_ids.to(self.device						)						)[0]

						# duplicate text embeddings for each generation per prompt, using mps friendly method
						UpperCamelCase  ,  UpperCamelCase  ,  UpperCamelCase         =					text_embeddings.shape
						UpperCamelCase         =					text_embeddings.repeat(1       ,       __magic_name__       ,       1						)
						UpperCamelCase         =					text_embeddings.view(bs_embed * num_images_per_prompt       ,       __magic_name__       ,       -1						)

						# 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.
						UpperCamelCase         =					guidance_scale > 1.0
						# get unconditional embeddings for classifier free guidance
						if do_classifier_free_guidance:
									UpperCamelCase         =					42
									if negative_prompt is None:
												UpperCamelCase         =					[""""""]
									elif type(__magic_name__						) is not type(__magic_name__						):
												raise TypeError(
												    F'`negative_prompt` should be the same type to `prompt`, but got {type(__magic_name__						)} !='
												    F' {type(__magic_name__						)}.'						)
									elif isinstance(__magic_name__       ,       __magic_name__						):
												UpperCamelCase         =					[negative_prompt]
									elif batch_size != len(__magic_name__						):
												raise ValueError(
												    F'`negative_prompt`: {negative_prompt} has batch size {len(__magic_name__						)}, but `prompt`:'
												    F' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'
												    """ the batch size of `prompt`."""						)
									else:
												UpperCamelCase         =					negative_prompt

									UpperCamelCase         =					text_input_ids.shape[-1]
									UpperCamelCase         =					self.tokenizer(
									    __magic_name__       ,       padding="""max_length"""       ,       max_length=__magic_name__       ,       truncation=__magic_name__       ,       return_tensors="""pt"""       ,       )
									UpperCamelCase         =					self.text_encoder(uncond_input.input_ids.to(self.device						)						)[0]

									# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
									UpperCamelCase         =					uncond_embeddings.shape[1]
									UpperCamelCase         =					uncond_embeddings.repeat(__magic_name__       ,       __magic_name__       ,       1						)
									UpperCamelCase         =					uncond_embeddings.view(batch_size * num_images_per_prompt       ,       __magic_name__       ,       -1						)

									# 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
									UpperCamelCase         =					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`.
						UpperCamelCase         =					(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
						UpperCamelCase         =					(batch_size * num_images_per_prompt, self.unet.config.in_channels, 6_4, 6_4)
						UpperCamelCase         =					text_embeddings.dtype
						if latents is None:
									if self.device.type == "mps":
												# randn does not exist on mps
												UpperCamelCase         =					torch.randn(
												    __magic_name__       ,       generator=__magic_name__       ,       device="""cpu"""       ,       dtype=__magic_name__						).to(self.device						)
												UpperCamelCase         =					torch.randn(__magic_name__       ,       generator=__magic_name__       ,       device="""cpu"""       ,       dtype=__magic_name__						).to(
												    self.device						)
									else:
												UpperCamelCase         =					torch.randn(
												    __magic_name__       ,       generator=__magic_name__       ,       device=self.device       ,       dtype=__magic_name__						)
												UpperCamelCase         =					torch.randn(__magic_name__       ,       generator=__magic_name__       ,       device=self.device       ,       dtype=__magic_name__						)
						else:
									if latents_reference.shape != latents_shape:
												raise ValueError(F'Unexpected latents shape, got {latents.shape}, expected {latents_shape}'						)
									UpperCamelCase         =					latents_reference.to(self.device						)
									UpperCamelCase         =					latents.to(self.device						)

						# This is the key part of the pipeline where we
						# try to ensure that the generated images w/ the same seed
						# but different sizes actually result in similar images
						UpperCamelCase         =					(latents_shape[3] - latents_shape_reference[3]) // 2
						UpperCamelCase         =					(latents_shape[2] - latents_shape_reference[2]) // 2
						UpperCamelCase         =					latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
						UpperCamelCase         =					latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
						UpperCamelCase         =					0 if dx < 0 else dx
						UpperCamelCase         =					0 if dy < 0 else dy
						UpperCamelCase         =					max(-dx       ,       0						)
						UpperCamelCase         =					max(-dy       ,       0						)
						# import pdb
						# pdb.set_trace()
						UpperCamelCase         =					latents_reference[:, :, dy : dy + h, dx : dx + w]

						# set timesteps
						self.scheduler.set_timesteps(__magic_name__						)

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

						# scale the initial noise by the standard deviation required by the scheduler
						UpperCamelCase         =					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]
						UpperCamelCase         =					"""eta""" in set(inspect.signature(self.scheduler.step						).parameters.keys()						)
						UpperCamelCase         =					{}
						if accepts_eta:
									UpperCamelCase         =					eta

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

									# predict the noise residual
									UpperCamelCase         =					self.unet(__magic_name__       ,       __magic_name__       ,       encoder_hidden_states=__magic_name__						).sample

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

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

									# call the callback, if provided
									if callback is not None and i % callback_steps == 0:
												callback(__magic_name__       ,       __magic_name__       ,       __magic_name__						)

						UpperCamelCase         =					1 / 0.18_215 * latents
						UpperCamelCase         =					self.vae.decode(__magic_name__						).sample

						UpperCamelCase         =					(image / 2 + 0.5).clamp(0       ,       1						)

						# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
						UpperCamelCase         =					image.cpu().permute(0       ,       2       ,       3       ,       1						).float().numpy()

						if self.safety_checker is not None:
									UpperCamelCase         =					self.feature_extractor(self.numpy_to_pil(__magic_name__						)       ,       return_tensors="""pt"""						).to(
									    self.device						)
									UpperCamelCase  ,  UpperCamelCase         =					self.safety_checker(
									    images=__magic_name__       ,       clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype						)						)
						else:
									UpperCamelCase         =					None

						if output_type == "pil":
									UpperCamelCase         =					self.numpy_to_pil(__magic_name__						)

						if not return_dict:
									return (image, has_nsfw_concept)

						return StableDiffusionPipelineOutput(images=__magic_name__       ,       nsfw_content_detected=__magic_name__						)








import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyInpaintPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()




class    UpperCAmelCase					(       __snake_case      , unittest.TestCase    ):
			lowercase						= KandinskyInpaintPipeline
			lowercase						= ["""prompt""", """image_embeds""", """negative_image_embeds""", """image""", """mask_image"""]
			lowercase						= [
			    """prompt""",
			    """negative_prompt""",
			    """image_embeds""",
			    """negative_image_embeds""",
			    """image""",
			    """mask_image""",
			]
			lowercase						= [
			    """generator""",
			    """height""",
			    """width""",
			    """latents""",
			    """guidance_scale""",
			    """negative_prompt""",
			    """num_inference_steps""",
			    """return_dict""",
			    """guidance_scale""",
			    """num_images_per_prompt""",
			    """output_type""",
			    """return_dict""",
			]
			lowercase						= False




			@property
			def   lowerCamelCase_					(						self							:		Union[str, Any]						):







						"""simple docstring"""







						return 3_2




			@property
			def   lowerCamelCase_					(						self							:		Optional[Any]						):







						"""simple docstring"""







						return 3_2




			@property
			def   lowerCamelCase_					(						self							:		List[Any]						):







						"""simple docstring"""







						return self.time_input_dim




			@property
			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""simple docstring"""







						return self.time_input_dim * 4




			@property
			def   lowerCamelCase_					(						self							:		str						):







						"""simple docstring"""







						return 1_0_0




			@property
			def   lowerCamelCase_					(						self							:		Optional[Any]						):







						"""simple docstring"""







						UpperCamelCase         =					XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""						)
						return tokenizer




			@property
			def   lowerCamelCase_					(						self							:		Any						):







						"""simple docstring"""







						torch.manual_seed(0						)
						UpperCamelCase         =					MCLIPConfig(
						    numDims=self.cross_attention_dim       ,       transformerDimensions=self.text_embedder_hidden_size       ,       hidden_size=self.text_embedder_hidden_size       ,       intermediate_size=3_7       ,       num_attention_heads=4       ,       num_hidden_layers=5       ,       vocab_size=1_0_0_5       ,       )

						UpperCamelCase         =					MultilingualCLIP(__magic_name__						)
						UpperCamelCase         =					text_encoder.eval()

						return text_encoder




			@property
			def   lowerCamelCase_					(						self							:		List[str]						):







						"""simple docstring"""







						torch.manual_seed(0						)

						UpperCamelCase         =					{
						    """in_channels""": 9,
						    # Out channels is double in channels because predicts mean and variance
						    """out_channels""": 8,
						    """addition_embed_type""": """text_image""",
						    """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
						    """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
						    """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
						    """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
						    """layers_per_block""": 1,
						    """encoder_hid_dim""": self.text_embedder_hidden_size,
						    """encoder_hid_dim_type""": """text_image_proj""",
						    """cross_attention_dim""": self.cross_attention_dim,
						    """attention_head_dim""": 4,
						    """resnet_time_scale_shift""": """scale_shift""",
						    """class_embed_type""": None,
						}

						UpperCamelCase         =					UNetaDConditionModel(**__magic_name__						)
						return model




			@property
			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""simple docstring"""







						return {
						    "block_out_channels": [3_2, 6_4],
						    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
						    "in_channels": 3,
						    "latent_channels": 4,
						    "layers_per_block": 1,
						    "norm_num_groups": 8,
						    "norm_type": "spatial",
						    "num_vq_embeddings": 1_2,
						    "out_channels": 3,
						    "up_block_types": [
						        "AttnUpDecoderBlock2D",
						        "UpDecoderBlock2D",
						    ],
						    "vq_embed_dim": 4,
						}




			@property
			def   lowerCamelCase_					(						self							:		Union[str, Any]						):







						"""simple docstring"""







						torch.manual_seed(0						)
						UpperCamelCase         =					VQModel(**self.dummy_movq_kwargs						)
						return model




			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""simple docstring"""







						UpperCamelCase         =					self.dummy_text_encoder
						UpperCamelCase         =					self.dummy_tokenizer
						UpperCamelCase         =					self.dummy_unet
						UpperCamelCase         =					self.dummy_movq

						UpperCamelCase         =					DDIMScheduler(
						    num_train_timesteps=1_0_0_0       ,       beta_schedule="""linear"""       ,       beta_start=0.00_085       ,       beta_end=0.012       ,       clip_sample=__magic_name__       ,       set_alpha_to_one=__magic_name__       ,       steps_offset=1       ,       prediction_type="""epsilon"""       ,       thresholding=__magic_name__       ,       )

						UpperCamelCase         =					{
						    """text_encoder""": text_encoder,
						    """tokenizer""": tokenizer,
						    """unet""": unet,
						    """scheduler""": scheduler,
						    """movq""": movq,
						}

						return components




			def   lowerCamelCase_					(						self							:		Tuple       ,       __magic_name__							:		Tuple       ,       __magic_name__							:		Optional[int]=0						):







						"""simple docstring"""







						UpperCamelCase         =					floats_tensor((1, self.cross_attention_dim)       ,       rng=random.Random(__magic_name__						)						).to(__magic_name__						)
						UpperCamelCase         =					floats_tensor((1, self.cross_attention_dim)       ,       rng=random.Random(seed + 1						)						).to(__magic_name__						)
						# create init_image
						UpperCamelCase         =					floats_tensor((1, 3, 6_4, 6_4)       ,       rng=random.Random(__magic_name__						)						).to(__magic_name__						)
						UpperCamelCase         =					image.cpu().permute(0       ,       2       ,       3       ,       1						)[0]
						UpperCamelCase         =					Image.fromarray(np.uinta(__magic_name__						)						).convert("""RGB"""						).resize((2_5_6, 2_5_6)						)
						# create mask
						UpperCamelCase         =					np.ones((6_4, 6_4)       ,       dtype=np.floataa						)
						UpperCamelCase         =					0

						if str(__magic_name__						).startswith("""mps"""						):
									UpperCamelCase         =					torch.manual_seed(__magic_name__						)
						else:
									UpperCamelCase         =					torch.Generator(device=__magic_name__						).manual_seed(__magic_name__						)
						UpperCamelCase         =					{
						    """prompt""": """horse""",
						    """image""": init_image,
						    """mask_image""": mask,
						    """image_embeds""": image_embeds,
						    """negative_image_embeds""": negative_image_embeds,
						    """generator""": generator,
						    """height""": 6_4,
						    """width""": 6_4,
						    """num_inference_steps""": 2,
						    """guidance_scale""": 4.0,
						    """output_type""": """np""",
						}
						return inputs




			def   lowerCamelCase_					(						self							:		Union[str, Any]						):







						"""simple docstring"""







						UpperCamelCase         =					"""cpu"""

						UpperCamelCase         =					self.get_dummy_components()

						UpperCamelCase         =					self.pipeline_class(**__magic_name__						)
						UpperCamelCase         =					pipe.to(__magic_name__						)

						pipe.set_progress_bar_config(disable=__magic_name__						)

						UpperCamelCase         =					pipe(**self.get_dummy_inputs(__magic_name__						)						)
						UpperCamelCase         =					output.images

						UpperCamelCase         =					pipe(
						    **self.get_dummy_inputs(__magic_name__						)       ,       return_dict=__magic_name__       ,       )[0]

						UpperCamelCase         =					image[0, -3:, -3:, -1]
						UpperCamelCase         =					image_from_tuple[0, -3:, -3:, -1]

						print(F'image.shape {image.shape}'						)

						assert image.shape == (1, 6_4, 6_4, 3)

						UpperCamelCase         =					np.array(
						    [0.8_326_919, 0.73_790_467, 0.20_918_581, 0.9_309_612, 0.5_511_791, 0.43_713_328, 0.5_513_321, 0.49_922_934, 0.59_497_786]						)

						assert (
						    np.abs(image_slice.flatten() - expected_slice						).max() < 1e-2
						), F' expected_slice {expected_slice}, but got {image_slice.flatten()}'
						assert (
						    np.abs(image_from_tuple_slice.flatten() - expected_slice						).max() < 1e-2
						), F' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'





			def   lowerCamelCase_					(						self							:		Dict						):







						"""simple docstring"""







						super().test_inference_batch_single_identical(expected_max_diff=3e-3						)




@slow
@require_torch_gpu
class    UpperCAmelCase					(       unittest.TestCase    ):




			def   lowerCamelCase_					(						self							:		Dict						):







						"""simple docstring"""







						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()





			def   lowerCamelCase_					(						self							:		Union[str, Any]						):







						"""simple docstring"""







						UpperCamelCase         =					load_numpy(
						    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
						    """/kandinsky/kandinsky_inpaint_cat_with_hat_fp16.npy"""						)

						UpperCamelCase         =					load_image(
						    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png"""						)
						UpperCamelCase         =					np.ones((7_6_8, 7_6_8)       ,       dtype=np.floataa						)
						UpperCamelCase         =					0

						UpperCamelCase         =					"""a hat"""

						UpperCamelCase         =					KandinskyPriorPipeline.from_pretrained(
						    """kandinsky-community/kandinsky-2-1-prior"""       ,       torch_dtype=torch.floataa						)
						pipe_prior.to(__magic_name__						)

						UpperCamelCase         =					KandinskyInpaintPipeline.from_pretrained(
						    """kandinsky-community/kandinsky-2-1-inpaint"""       ,       torch_dtype=torch.floataa						)
						UpperCamelCase         =					pipeline.to(__magic_name__						)
						pipeline.set_progress_bar_config(disable=__magic_name__						)

						UpperCamelCase         =					torch.Generator(device="""cpu"""						).manual_seed(0						)
						UpperCamelCase  ,  UpperCamelCase         =					pipe_prior(
						    __magic_name__       ,       generator=__magic_name__       ,       num_inference_steps=5       ,       negative_prompt=""""""       ,       ).to_tuple()

						UpperCamelCase         =					pipeline(
						    __magic_name__       ,       image=__magic_name__       ,       mask_image=__magic_name__       ,       image_embeds=__magic_name__       ,       negative_image_embeds=__magic_name__       ,       generator=__magic_name__       ,       num_inference_steps=1_0_0       ,       height=7_6_8       ,       width=7_6_8       ,       output_type="""np"""       ,       )

						UpperCamelCase         =					output.images[0]

						assert image.shape == (7_6_8, 7_6_8, 3)

						assert_mean_pixel_difference(__magic_name__       ,       __magic_name__						)




