

import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import MaskFormerSwinBackbone
		from transformers.models.maskformer import MaskFormerSwinModel


class SCREAMING_SNAKE_CASE	:






			"""simple docstring"""




			def __init__(     self			,					__UpperCamelCase			,					__UpperCamelCase=13			,					__UpperCamelCase=32			,					__UpperCamelCase=2			,					__UpperCamelCase=3			,					__UpperCamelCase=16			,					__UpperCamelCase=[1, 2, 1]			,					__UpperCamelCase=[2, 2, 4]			,					__UpperCamelCase=2			,					__UpperCamelCase=2.0			,					__UpperCamelCase=True			,					__UpperCamelCase=0.0			,					__UpperCamelCase=0.0			,					__UpperCamelCase=0.1			,					__UpperCamelCase="gelu"			,					__UpperCamelCase=False			,					__UpperCamelCase=True			,					__UpperCamelCase=0.02			,					__UpperCamelCase=1E-5			,					__UpperCamelCase=True			,					__UpperCamelCase=None			,					__UpperCamelCase=True			,					__UpperCamelCase=10			,					__UpperCamelCase=8			,					__UpperCamelCase=["stage1", "stage2", "stage3"]			,					__UpperCamelCase=[1, 2, 3]			,					):

				"""simple docstring"""


				snake_case_   		=			parent
				snake_case_   		=			batch_size
				snake_case_   		=			image_size
				snake_case_   		=			patch_size
				snake_case_   		=			num_channels
				snake_case_   		=			embed_dim
				snake_case_   		=			depths
				snake_case_   		=			num_heads
				snake_case_   		=			window_size
				snake_case_   		=			mlp_ratio
				snake_case_   		=			qkv_bias
				snake_case_   		=			hidden_dropout_prob
				snake_case_   		=			attention_probs_dropout_prob
				snake_case_   		=			drop_path_rate
				snake_case_   		=			hidden_act
				snake_case_   		=			use_absolute_embeddings
				snake_case_   		=			patch_norm
				snake_case_   		=			layer_norm_eps
				snake_case_   		=			initializer_range
				snake_case_   		=			is_training
				snake_case_   		=			scope
				snake_case_   		=			use_labels
				snake_case_   		=			type_sequence_label_size
				snake_case_   		=			encoder_stride
				snake_case_   		=			out_features
				snake_case_   		=			out_indices


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

				snake_case_   		=			None
				if self.use_labels:
					snake_case_   		=			ids_tensor([self.batch_size]			,					self.type_sequence_label_size				)

				snake_case_   		=			self.get_config()

				return config, pixel_values, labels


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				return MaskFormerSwinConfig(
				    image_size=self.image_size			,					patch_size=self.patch_size			,					num_channels=self.num_channels			,					embed_dim=self.embed_dim			,					depths=self.depths			,					num_heads=self.num_heads			,					window_size=self.window_size			,					mlp_ratio=self.mlp_ratio			,					qkv_bias=self.qkv_bias			,					hidden_dropout_prob=self.hidden_dropout_prob			,					attention_probs_dropout_prob=self.attention_probs_dropout_prob			,					drop_path_rate=self.drop_path_rate			,					hidden_act=self.hidden_act			,					use_absolute_embeddings=self.use_absolute_embeddings			,					path_norm=self.patch_norm			,					layer_norm_eps=self.layer_norm_eps			,					initializer_range=self.initializer_range			,					encoder_stride=self.encoder_stride			,					out_features=self.out_features			,					out_indices=self.out_indices			,					)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			MaskFormerSwinModel(config=__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase				)

				snake_case_   		=			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
				snake_case_   		=			int(config.embed_dim * 2 ** (len(config.depths				) - 1)				)

				self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, expected_seq_len, expected_dim)				)


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			MaskFormerSwinBackbone(config=__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()
				snake_case_   		=			model(__UpperCamelCase				)

				# verify feature maps
				self.parent.assertEqual(len(result.feature_maps				)			,					len(config.out_features				)				)
				self.parent.assertListEqual(list(result.feature_maps[0].shape				)			,					[13, 16, 16, 16]				)

				# verify channels
				self.parent.assertEqual(len(model.channels				)			,					len(config.out_features				)				)
				self.parent.assertListEqual(model.channels			,					[16, 32, 64]				)

				# verify ValueError
				with self.parent.assertRaises(__UpperCamelCase				):
					snake_case_   		=			['stem']
					snake_case_   		=			MaskFormerSwinBackbone(config=__UpperCamelCase				)







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.prepare_config_and_inputs()
				snake_case_		,							snake_case_		,							snake_case_   		=			config_and_inputs
				snake_case_   		=			{'pixel_values': pixel_values}
				return config, inputs_dict







@require_torch
class SCREAMING_SNAKE_CASE	(		__snake_case				,    __snake_case				,    unittest.TestCase				):






			"""simple docstring"""




			__A    	=	(
			    (
			        MaskFormerSwinModel,
			        MaskFormerSwinBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			__A    	=	{"""feature-extraction""": MaskFormerSwinModel} if is_torch_available() else {}
			__A    	=	False
			__A    	=	False
			__A    	=	False
			__A    	=	False
			__A    	=	False


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			MaskFormerSwinModelTester(self				)
				snake_case_   		=			ConfigTester(self			,					config_class=__UpperCamelCase			,					embed_dim=37				)


			@require_torch_multi_gpu
			@unittest.skip(
			    reason=(
			        '`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'
			        ' `nn.DataParallel`'
			    )				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				self.create_and_test_config_common_properties()
				self.config_tester.create_and_test_config_to_json_string()
				self.config_tester.create_and_test_config_to_json_file()
				self.config_tester.create_and_test_config_from_and_save_pretrained()
				self.config_tester.create_and_test_config_with_num_labels()
				self.config_tester.check_config_can_be_init_without_params()
				self.config_tester.check_config_arguments_init()


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				return


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_backbone(*__UpperCamelCase				)


			@unittest.skip('Swin does not use inputs_embeds'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			@unittest.skip('Swin does not support feedforward chunking'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					snake_case_   		=			model_class(__UpperCamelCase				)
					self.assertIsInstance(model.get_input_embeddings()			,					(nn.Module)				)
					snake_case_   		=			model.get_output_embeddings()
					self.assertTrue(x is None or isinstance(__UpperCamelCase			,					nn.Linear				)				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
					snake_case_   		=			model_class(__UpperCamelCase				)
					snake_case_   		=			inspect.signature(model.forward				)
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					snake_case_   		=			[*signature.parameters.keys()]

					snake_case_   		=			['pixel_values']
					self.assertListEqual(arg_names[:1]			,					__UpperCamelCase				)


			@unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			@unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				):

				"""simple docstring"""


				snake_case_   		=			model_class(__UpperCamelCase				)
				model.to(__UpperCamelCase				)
				model.eval()

				with torch.no_grad():
					snake_case_   		=			model(**self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase				)				)

				snake_case_   		=			outputs.hidden_states

				snake_case_   		=			getattr(
				    self.model_tester			,					'expected_num_hidden_layers'			,					len(self.model_tester.depths				) + 1				)
				self.assertEqual(len(__UpperCamelCase				)			,					__UpperCamelCase				)

				# Swin has a different seq_length
				snake_case_   		=			(
				    config.patch_size
				    if isinstance(config.patch_size			,					collections.abc.Iterable				)
				    else (config.patch_size, config.patch_size)
				)

				snake_case_   		=			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

				self.assertListEqual(
				    list(hidden_states[0].shape[-2:]				)			,					[num_patches, self.model_tester.embed_dim]			,					)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

				snake_case_   		=			(
				    self.model_tester.image_size
				    if isinstance(self.model_tester.image_size			,					collections.abc.Iterable				)
				    else (self.model_tester.image_size, self.model_tester.image_size)
				)

				for model_class in self.all_model_classes:
					snake_case_   		=			True
					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				)

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					snake_case_   		=			True

					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()
				snake_case_   		=			3

				snake_case_   		=			(
				    self.model_tester.image_size
				    if isinstance(self.model_tester.image_size			,					collections.abc.Iterable				)
				    else (self.model_tester.image_size, self.model_tester.image_size)
				)
				snake_case_   		=			(
				    config.patch_size
				    if isinstance(config.patch_size			,					collections.abc.Iterable				)
				    else (config.patch_size, config.patch_size)
				)

				snake_case_   		=			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
				snake_case_   		=			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

				for model_class in self.all_model_classes:
					snake_case_   		=			True
					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					(padded_height, padded_width)				)

					# check that output_hidden_states also work using config
					del inputs_dict["output_hidden_states"]
					snake_case_   		=			True
					self.check_hidden_states_output(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					(padded_height, padded_width)				)


			@unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass


			@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'				)
			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				pass







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()

				def set_nan_tensor_to_zero(__UpperCamelCase				):
					snake_case_   		=			0
					return t

				def check_equivalence(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase={}				):
					with torch.no_grad():
						snake_case_   		=			model(**__UpperCamelCase			,					return_dict=__UpperCamelCase			,					**__UpperCamelCase				)
						snake_case_   		=			model(**__UpperCamelCase			,					return_dict=__UpperCamelCase			,					**__UpperCamelCase				).to_tuple()

						def recursive_check(__UpperCamelCase			,					__UpperCamelCase				):
							if isinstance(__UpperCamelCase			,					(List, Tuple)				):
								for tuple_iterable_value, dict_iterable_value in zip(__UpperCamelCase			,					__UpperCamelCase				):
									recursive_check(__UpperCamelCase			,					__UpperCamelCase				)
							elif isinstance(__UpperCamelCase			,					__UpperCamelCase				):
								for tuple_iterable_value, dict_iterable_value in zip(
								    tuple_object.values()			,					dict_object.values()				):
									recursive_check(__UpperCamelCase			,					__UpperCamelCase				)
							elif tuple_object is None:
								return
							else:
								self.assertTrue(
								    torch.allclose(
								        set_nan_tensor_to_zero(__UpperCamelCase				)			,					set_nan_tensor_to_zero(__UpperCamelCase				)			,					atol=1E-5				)			,					msg=(
								        'Tuple and dict output are not equal. Difference:'
								        f""" {torch.max(torch.abs(tuple_object - dict_object				)				)}. Tuple has `nan`:"""
								        f""" {torch.isnan(__UpperCamelCase				).any()} and `inf`: {torch.isinf(__UpperCamelCase				)}. Dict has"""
								        f""" `nan`: {torch.isnan(__UpperCamelCase				).any()} and `inf`: {torch.isinf(__UpperCamelCase				)}."""
								    )			,					)

						recursive_check(__UpperCamelCase			,					__UpperCamelCase				)

				for model_class in self.all_model_classes:
					snake_case_   		=			model_class(__UpperCamelCase				)
					model.to(__UpperCamelCase				)
					model.eval()

					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase				)
					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase				)
					check_equivalence(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				)

					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase			,					return_labels=__UpperCamelCase				)
					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase			,					return_labels=__UpperCamelCase				)
					check_equivalence(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				)

					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase				)
					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase				)
					check_equivalence(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					{'output_hidden_states': True}				)

					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase			,					return_labels=__UpperCamelCase				)
					snake_case_   		=			self._prepare_for_class(__UpperCamelCase			,					__UpperCamelCase			,					return_labels=__UpperCamelCase				)
					check_equivalence(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase			,					{'output_hidden_states': True}				)







@require_torch
class SCREAMING_SNAKE_CASE	(		unittest.TestCase				,    __snake_case				):






			"""simple docstring"""




			__A    	=	(MaskFormerSwinBackbone,) if is_torch_available() else ()
			__A    	=	MaskFormerSwinConfig


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			MaskFormerSwinModelTester(self				)







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_		,							snake_case_   		=			self.model_tester.prepare_config_and_inputs_for_common()
				snake_case_   		=			inputs_dict['pixel_values'].shape[0]

				for backbone_class in self.all_model_classes:
					snake_case_   		=			backbone_class(__UpperCamelCase				)
					backbone.to(__UpperCamelCase				)
					backbone.eval()

					snake_case_   		=			backbone(**__UpperCamelCase				)

					# Test default outputs and verify feature maps
					self.assertIsInstance(outputs.feature_maps			,					__UpperCamelCase				)
					self.assertTrue(len(outputs.feature_maps				) == len(backbone.channels				)				)
					for feature_map, n_channels in zip(outputs.feature_maps			,					backbone.channels				):
						self.assertTrue(feature_map.shape[:2]			,					(batch_size, n_channels)				)
					self.assertIsNone(outputs.hidden_states				)
					self.assertIsNone(outputs.attentions				)

					# Test output_hidden_states=True
					snake_case_   		=			backbone(**__UpperCamelCase			,					output_hidden_states=__UpperCamelCase				)
					self.assertIsNotNone(outputs.hidden_states				)
					self.assertTrue(len(outputs.hidden_states				)			,					len(backbone.stage_names				)				)
					# We skip the stem layer
					for hidden_states, n_channels in zip(outputs.hidden_states[1:]			,					backbone.channels				):
						for hidden_state in hidden_states:
							# Hidden states are in the format (batch_size, (height * width), n_channels)
							snake_case_		,							snake_case_		,							snake_case_   		=			hidden_state.shape
							self.assertTrue((h_batch_size, h_n_channels)			,					(batch_size, n_channels)				)

            # Test output_attentions=True
					if self.has_attentions:
						snake_case_   		=			backbone(**__UpperCamelCase			,					output_attentions=__UpperCamelCase				)
						self.assertIsNotNone(outputs.attentions				)



import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class SCREAMING_SNAKE_CASE	(		__snake_case				,    __snake_case				,    unittest.TestCase				):






			"""simple docstring"""




			__A    	=	StableDiffusionDiffEditPipeline
			__A    	=	TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""height""", """width""", """image"""} | {"""image_latents"""}
			__A    	=	TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {"""image"""} | {"""image_latents"""}
			__A    	=	frozenset(
			    []				)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
			__A    	=	frozenset([]				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				torch.manual_seed(0				)
				snake_case_   		=			UNetaDConditionModel(
				    block_out_channels=(32, 64)			,					layers_per_block=2			,					sample_size=32			,					in_channels=4			,					out_channels=4			,					down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')			,					up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')			,					cross_attention_dim=32			,					attention_head_dim=(2, 4)			,					use_linear_projection=__UpperCamelCase			,					)
				snake_case_   		=			DDIMScheduler(
				    beta_start=0.0_0085			,					beta_end=0.012			,					beta_schedule='scaled_linear'			,					clip_sample=__UpperCamelCase			,					set_alpha_to_one=__UpperCamelCase			,					)
				snake_case_   		=			DDIMInverseScheduler(
				    beta_start=0.0_0085			,					beta_end=0.012			,					beta_schedule='scaled_linear'			,					clip_sample=__UpperCamelCase			,					set_alpha_to_zero=__UpperCamelCase			,					)
				torch.manual_seed(0				)
				snake_case_   		=			AutoencoderKL(
				    block_out_channels=[32, 64]			,					in_channels=3			,					out_channels=3			,					down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']			,					up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']			,					latent_channels=4			,					sample_size=1_28			,					)
				torch.manual_seed(0				)
				snake_case_   		=			CLIPTextConfig(
				    bos_token_id=0			,					eos_token_id=2			,					hidden_size=32			,					intermediate_size=37			,					layer_norm_eps=1E-05			,					num_attention_heads=4			,					num_hidden_layers=5			,					pad_token_id=1			,					vocab_size=10_00			,					hidden_act='gelu'			,					projection_dim=5_12			,					)
				snake_case_   		=			CLIPTextModel(__UpperCamelCase				)
				snake_case_   		=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)

				snake_case_   		=			{
				    'unet': unet,
				    'scheduler': scheduler,
				    'inverse_scheduler': inverse_scheduler,
				    'vae': vae,
				    'text_encoder': text_encoder,
				    'tokenizer': tokenizer,
				    'safety_checker': None,
				    'feature_extractor': None,
				}

				return components


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase=0				):

				"""simple docstring"""


				snake_case_   		=			floats_tensor((1, 16, 16)			,					rng=random.Random(__UpperCamelCase				)				).to(__UpperCamelCase				)
				snake_case_   		=			floats_tensor((1, 2, 4, 16, 16)			,					rng=random.Random(__UpperCamelCase				)				).to(__UpperCamelCase				)
				if str(__UpperCamelCase				).startswith('mps'				):
					snake_case_   		=			torch.manual_seed(__UpperCamelCase				)
				else:
					snake_case_   		=			torch.Generator(device=__UpperCamelCase				).manual_seed(__UpperCamelCase				)
				snake_case_   		=			{
				    'prompt': 'a dog and a newt',
				    'mask_image': mask,
				    'image_latents': latents,
				    'generator': generator,
				    'num_inference_steps': 2,
				    'inpaint_strength': 1.0,
				    'guidance_scale': 6.0,
				    'output_type': 'numpy',
				}

				return inputs


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase=0				):

				"""simple docstring"""


				snake_case_   		=			floats_tensor((1, 3, 32, 32)			,					rng=random.Random(__UpperCamelCase				)				).to(__UpperCamelCase				)
				snake_case_   		=			image.cpu().permute(0			,					2			,					3			,					1				)[0]
				snake_case_   		=			Image.fromarray(np.uinta(__UpperCamelCase				)				).convert('RGB'				)
				if str(__UpperCamelCase				).startswith('mps'				):
					snake_case_   		=			torch.manual_seed(__UpperCamelCase				)
				else:
					snake_case_   		=			torch.Generator(device=__UpperCamelCase				).manual_seed(__UpperCamelCase				)
				snake_case_   		=			{
				    'image': image,
				    'source_prompt': 'a cat and a frog',
				    'target_prompt': 'a dog and a newt',
				    'generator': generator,
				    'num_inference_steps': 2,
				    'num_maps_per_mask': 2,
				    'mask_encode_strength': 1.0,
				    'guidance_scale': 6.0,
				    'output_type': 'numpy',
				}

				return inputs


			def       __lowerCAmelCase			(     self			,					__UpperCamelCase			,					__UpperCamelCase=0				):

				"""simple docstring"""


				snake_case_   		=			floats_tensor((1, 3, 32, 32)			,					rng=random.Random(__UpperCamelCase				)				).to(__UpperCamelCase				)
				snake_case_   		=			image.cpu().permute(0			,					2			,					3			,					1				)[0]
				snake_case_   		=			Image.fromarray(np.uinta(__UpperCamelCase				)				).convert('RGB'				)
				if str(__UpperCamelCase				).startswith('mps'				):
					snake_case_   		=			torch.manual_seed(__UpperCamelCase				)
				else:
					snake_case_   		=			torch.Generator(device=__UpperCamelCase				).manual_seed(__UpperCamelCase				)
				snake_case_   		=			{
				    'image': image,
				    'prompt': 'a cat and a frog',
				    'generator': generator,
				    'num_inference_steps': 2,
				    'inpaint_strength': 1.0,
				    'guidance_scale': 6.0,
				    'decode_latents': True,
				    'output_type': 'numpy',
				}
				return inputs


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				if not hasattr(self.pipeline_class			,					'_optional_components'				):
					return

				snake_case_   		=			self.get_dummy_components()
				snake_case_   		=			self.pipeline_class(**__UpperCamelCase				)
				pipe.to(__UpperCamelCase				)
				pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				# set all optional components to None and update pipeline config accordingly
				for optional_component in pipe._optional_components:
					setattr(__UpperCamelCase			,					__UpperCamelCase			,					__UpperCamelCase				)
				pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}				)

				snake_case_   		=			self.get_dummy_inputs(__UpperCamelCase				)
				snake_case_   		=			pipe(**__UpperCamelCase				)[0]

				with tempfile.TemporaryDirectory() as tmpdir:
					pipe.save_pretrained(__UpperCamelCase				)
					snake_case_   		=			self.pipeline_class.from_pretrained(__UpperCamelCase				)
					pipe_loaded.to(__UpperCamelCase				)
					pipe_loaded.set_progress_bar_config(disable=__UpperCamelCase				)

				for optional_component in pipe._optional_components:
					self.assertTrue(
					    getattr(__UpperCamelCase			,					__UpperCamelCase				) is None			,					f"""`{optional_component}` did not stay set to None after loading."""			,					)

				snake_case_   		=			self.get_dummy_inputs(__UpperCamelCase				)
				snake_case_   		=			pipe_loaded(**__UpperCamelCase				)[0]

				snake_case_   		=			np.abs(output - output_loaded				).max()
				self.assertLess(__UpperCamelCase			,					1E-4				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			'cpu'

				snake_case_   		=			self.get_dummy_components()
				snake_case_   		=			self.pipeline_class(**__UpperCamelCase				)
				pipe.to(__UpperCamelCase				)
				pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			self.get_dummy_mask_inputs(__UpperCamelCase				)
				snake_case_   		=			pipe.generate_mask(**__UpperCamelCase				)
				snake_case_   		=			mask[0, -3:, -3:]

				self.assertEqual(mask.shape			,					(1, 16, 16)				)
				snake_case_   		=			np.array([0] * 9				)
				snake_case_   		=			np.abs(mask_slice.flatten() - expected_slice				).max()
				self.assertLessEqual(__UpperCamelCase			,					1E-3				)
				self.assertEqual(mask[0, -3, -4]			,					0				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			'cpu'

				snake_case_   		=			self.get_dummy_components()
				snake_case_   		=			self.pipeline_class(**__UpperCamelCase				)
				pipe.to(__UpperCamelCase				)
				pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			self.get_dummy_inversion_inputs(__UpperCamelCase				)
				snake_case_   		=			pipe.invert(**__UpperCamelCase				).images
				snake_case_   		=			image[0, -1, -3:, -3:]

				self.assertEqual(image.shape			,					(2, 32, 32, 3)				)
				snake_case_   		=			np.array(
				    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.5_1050, 0.5015, 0.4407, 0.4799]			,					)
				snake_case_   		=			np.abs(image_slice.flatten() - expected_slice				).max()
				self.assertLessEqual(__UpperCamelCase			,					1E-3				)


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				super().test_inference_batch_single_identical(expected_max_diff=5E-3				)







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			'cpu'

				snake_case_   		=			self.get_dummy_components()

				snake_case_   		=			{'beta_start': 0.0_0085, 'beta_end': 0.012, 'beta_schedule': 'scaled_linear'}
				snake_case_   		=			DPMSolverMultistepScheduler(**__UpperCamelCase				)
				snake_case_   		=			DPMSolverMultistepInverseScheduler(**__UpperCamelCase				)

				snake_case_   		=			self.pipeline_class(**__UpperCamelCase				)
				pipe.to(__UpperCamelCase				)
				pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			self.get_dummy_inversion_inputs(__UpperCamelCase				)
				snake_case_   		=			pipe.invert(**__UpperCamelCase				).images
				snake_case_   		=			image[0, -1, -3:, -3:]

				self.assertEqual(image.shape			,					(2, 32, 32, 3)				)
				snake_case_   		=			np.array(
				    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.5_1050, 0.5015, 0.4407, 0.4799]			,					)
				snake_case_   		=			np.abs(image_slice.flatten() - expected_slice				).max()
				self.assertLessEqual(__UpperCamelCase			,					1E-3				)







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






			"""simple docstring"""




			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


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


			@classmethod
			def       __lowerCAmelCase			(     cls				):

				"""simple docstring"""


				snake_case_   		=			load_image(
				    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png'				)

				snake_case_   		=			raw_image.convert('RGB'				).resize((7_68, 7_68)				)

				snake_case_   		=			raw_image


			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			torch.manual_seed(0				)

				snake_case_   		=			StableDiffusionDiffEditPipeline.from_pretrained(
				    'stabilityai/stable-diffusion-2-1'			,					safety_checker=__UpperCamelCase			,					torch_dtype=torch.floataa				)
				snake_case_   		=			DDIMScheduler.from_config(pipe.scheduler.config				)
				snake_case_   		=			DDIMInverseScheduler.from_config(pipe.scheduler.config				)
				pipe.enable_model_cpu_offload()
				pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			'a bowl of fruit'
				snake_case_   		=			'a bowl of pears'

				snake_case_   		=			pipe.generate_mask(
				    image=self.raw_image			,					source_prompt=__UpperCamelCase			,					target_prompt=__UpperCamelCase			,					generator=__UpperCamelCase			,					)

				snake_case_   		=			pipe.invert(
				    prompt=__UpperCamelCase			,					image=self.raw_image			,					inpaint_strength=0.7			,					generator=__UpperCamelCase				).latents

				snake_case_   		=			pipe(
				    prompt=__UpperCamelCase			,					mask_image=__UpperCamelCase			,					image_latents=__UpperCamelCase			,					generator=__UpperCamelCase			,					negative_prompt=__UpperCamelCase			,					inpaint_strength=0.7			,					output_type='numpy'			,					).images[0]

				snake_case_   		=			(
				    np.array(
				        load_image(
				            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
				            '/diffedit/pears.png'				).resize((7_68, 7_68)				)				)
				    / 2_55
				)
				assert np.abs((expected_image - image).max()				) < 5E-1







			def       __lowerCAmelCase			(     self				):

				"""simple docstring"""


				snake_case_   		=			torch.manual_seed(0				)

				snake_case_   		=			StableDiffusionDiffEditPipeline.from_pretrained(
				    'stabilityai/stable-diffusion-2-1'			,					safety_checker=__UpperCamelCase			,					torch_dtype=torch.floataa				)
				snake_case_   		=			DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
				snake_case_   		=			DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config				)
				pipe.enable_model_cpu_offload()
				pipe.set_progress_bar_config(disable=__UpperCamelCase				)

				snake_case_   		=			'a bowl of fruit'
				snake_case_   		=			'a bowl of pears'

				snake_case_   		=			pipe.generate_mask(
				    image=self.raw_image			,					source_prompt=__UpperCamelCase			,					target_prompt=__UpperCamelCase			,					generator=__UpperCamelCase			,					)

				snake_case_   		=			pipe.invert(
				    prompt=__UpperCamelCase			,					image=self.raw_image			,					inpaint_strength=0.7			,					generator=__UpperCamelCase			,					num_inference_steps=25			,					).latents

				snake_case_   		=			pipe(
				    prompt=__UpperCamelCase			,					mask_image=__UpperCamelCase			,					image_latents=__UpperCamelCase			,					generator=__UpperCamelCase			,					negative_prompt=__UpperCamelCase			,					inpaint_strength=0.7			,					num_inference_steps=25			,					output_type='numpy'			,					).images[0]

				snake_case_   		=			(
				    np.array(
				        load_image(
				            'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
				            '/diffedit/pears.png'				).resize((7_68, 7_68)				)				)
				    / 2_55
				)
				assert np.abs((expected_image - image).max()				) < 5E-1
