




'''simple docstring'''





from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers.models.layoutlm.modeling_tf_layoutlm import (
		    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFLayoutLMForMaskedLM,
		    TFLayoutLMForQuestionAnswering,
		    TFLayoutLMForSequenceClassification,
		    TFLayoutLMForTokenClassification,
		    TFLayoutLMModel,
		)




class 					_snake_case						:




			def __init__(   self							,				a__							,				a__=13							,				a__=7							,				a__=True							,				a__=True							,				a__=True							,				a__=True							,				a__=99							,				a__=32							,				a__=2							,				a__=4							,				a__=37							,				a__="gelu"							,				a__=0.1							,				a__=0.1							,				a__=512							,				a__=16							,				a__=2							,				a__=0.0_2							,				a__=3							,				a__=4							,				a__=None							,				a__=1_000							,				)							->							Any:

										'''simple docstring'''




										snake_case_         = parent
										snake_case_         = batch_size
										snake_case_         = seq_length
										snake_case_         = is_training
										snake_case_         = use_input_mask
										snake_case_         = use_token_type_ids
										snake_case_         = use_labels
										snake_case_         = vocab_size
										snake_case_         = hidden_size
										snake_case_         = num_hidden_layers
										snake_case_         = num_attention_heads
										snake_case_         = intermediate_size
										snake_case_         = hidden_act
										snake_case_         = hidden_dropout_prob
										snake_case_         = attention_probs_dropout_prob
										snake_case_         = max_position_embeddings
										snake_case_         = type_vocab_size
										snake_case_         = type_sequence_label_size
										snake_case_         = initializer_range
										snake_case_         = num_labels
										snake_case_         = num_choices
										snake_case_         = scope
										snake_case_         = range_bbox




			def   lowerCAmelCase__							(   self				)							->							Optional[Any]:

										'''simple docstring'''




										snake_case_         = ids_tensor([self.batch_size, self.seq_length]							,				self.vocab_size				)

										# convert bbox to numpy since TF does not support item assignment
										snake_case_         = ids_tensor([self.batch_size, self.seq_length, 4]							,				self.range_bbox				).numpy()
										# Ensure that bbox is legal
										for i in range(bbox.shape[0]				):
																	for j in range(bbox.shape[1]				):
																								if bbox[i, j, 3] < bbox[i, j, 1]:
																															snake_case_         = bbox[i, j, 3]
																															snake_case_         = bbox[i, j, 1]
																															snake_case_         = t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																															snake_case_         = bbox[i, j, 2]
																															snake_case_         = bbox[i, j, 0]
																															snake_case_         = t
										snake_case_         = tf.convert_to_tensor(a__				)

										snake_case_         = None
										if self.use_input_mask:
																	snake_case_         = random_attention_mask([self.batch_size, self.seq_length]				)

										snake_case_         = None
										if self.use_token_type_ids:
																	snake_case_         = ids_tensor([self.batch_size, self.seq_length]							,				self.type_vocab_size				)

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

										snake_case_         = LayoutLMConfig(
										    vocab_size=self.vocab_size							,				hidden_size=self.hidden_size							,				num_hidden_layers=self.num_hidden_layers							,				num_attention_heads=self.num_attention_heads							,				intermediate_size=self.intermediate_size							,				hidden_act=self.hidden_act							,				hidden_dropout_prob=self.hidden_dropout_prob							,				attention_probs_dropout_prob=self.attention_probs_dropout_prob							,				max_position_embeddings=self.max_position_embeddings							,				type_vocab_size=self.type_vocab_size							,				initializer_range=self.initializer_range							,				)

										return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




			def   lowerCAmelCase__							(   self							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__				)							->							List[Any]:

										'''simple docstring'''




										snake_case_         = TFLayoutLMModel(config=a__				)

										snake_case_         = model(a__							,				a__							,				attention_mask=a__							,				token_type_ids=a__				)
										snake_case_         = model(a__							,				a__							,				token_type_ids=a__				)
										snake_case_         = model(a__							,				a__				)
										self.parent.assertEqual(result.last_hidden_state.shape							,				(self.batch_size, self.seq_length, self.hidden_size)				)
										self.parent.assertEqual(result.pooler_output.shape							,				(self.batch_size, self.hidden_size)				)




			def   lowerCAmelCase__							(   self							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__				)							->							List[Any]:

										'''simple docstring'''




										snake_case_         = TFLayoutLMForMaskedLM(config=a__				)

										snake_case_         = model(a__							,				a__							,				attention_mask=a__							,				token_type_ids=a__							,				labels=a__				)
										self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.seq_length, self.vocab_size)				)




			def   lowerCAmelCase__							(   self							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__				)							->							List[str]:

										'''simple docstring'''




										snake_case_         = self.num_labels
										snake_case_         = TFLayoutLMForSequenceClassification(config=a__				)

										snake_case_         = model(a__							,				a__							,				attention_mask=a__							,				token_type_ids=a__				)
										self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.num_labels)				)




			def   lowerCAmelCase__							(   self							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__				)							->							List[Any]:

										'''simple docstring'''




										snake_case_         = self.num_labels
										snake_case_         = TFLayoutLMForTokenClassification(config=a__				)

										snake_case_         = model(a__							,				a__							,				attention_mask=a__							,				token_type_ids=a__							,				labels=a__				)
										self.parent.assertEqual(result.logits.shape							,				(self.batch_size, self.seq_length, self.num_labels)				)




			def   lowerCAmelCase__							(   self							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__							,				a__				)							->							Dict:

										'''simple docstring'''




										snake_case_         = TFLayoutLMForQuestionAnswering(config=a__				)

										snake_case_         = model(a__							,				a__							,				attention_mask=a__							,				token_type_ids=a__				)
										self.parent.assertEqual(result.start_logits.shape							,				(self.batch_size, self.seq_length)				)
										self.parent.assertEqual(result.end_logits.shape							,				(self.batch_size, self.seq_length)				)




			def   lowerCAmelCase__							(   self				)							->							List[Any]:

										'''simple docstring'''




										snake_case_         = self.prepare_config_and_inputs()
										(
										    (
										    snake_case_			
										)   , (
										    snake_case_			
										)   , (
										    snake_case_			
										)   , (
										    snake_case_			
										)   , (
										    snake_case_			
										)   , (
										    snake_case_			
										)   , (
										    snake_case_			
										)   , (
										    snake_case_			
										)   , 			
										)         = config_and_inputs
										snake_case_         = {
										    "input_ids": input_ids,
										    "bbox": bbox,
										    "token_type_ids": token_type_ids,
										    "attention_mask": input_mask,
										}
										return config, inputs_dict




@require_tf
class 					_snake_case						(      lowercase_		,		lowercase_		,		unittest.TestCase				):
			lowerCAmelCase_	: List[Any]					=       (
			    (
			        TFLayoutLMModel,
			        TFLayoutLMForMaskedLM,
			        TFLayoutLMForTokenClassification,
			        TFLayoutLMForSequenceClassification,
			        TFLayoutLMForQuestionAnswering,
			    )
			    if is_tf_available()
			    else ()
			)
			lowerCAmelCase_	: Optional[int]					=       (
			    {
			        "feature-extraction": TFLayoutLMModel,
			        "fill-mask": TFLayoutLMForMaskedLM,
			        "text-classification": TFLayoutLMForSequenceClassification,
			        "token-classification": TFLayoutLMForTokenClassification,
			        "zero-shot": TFLayoutLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowerCAmelCase_	: List[Any]					=       False
			lowerCAmelCase_	: Tuple					=       True
			lowerCAmelCase_	: Tuple					=       10




			def   lowerCAmelCase__							(   self				)							->							Optional[int]:

										'''simple docstring'''




										snake_case_         = TFLayoutLMModelTester(self				)
										snake_case_         = ConfigTester(self							,				config_class=a__							,				hidden_size=37				)




			def   lowerCAmelCase__							(   self				)							->							List[Any]:

										'''simple docstring'''




										self.config_tester.run_common_tests()




			def   lowerCAmelCase__							(   self				)							->							Dict:

										'''simple docstring'''




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




			def   lowerCAmelCase__							(   self				)							->							Dict:

										'''simple docstring'''




										snake_case_         = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*a__				)




			def   lowerCAmelCase__							(   self				)							->							Union[str, Any]:

										'''simple docstring'''




										snake_case_         = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*a__				)




			def   lowerCAmelCase__							(   self				)							->							int:

										'''simple docstring'''




										snake_case_         = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*a__				)




			def   lowerCAmelCase__							(   self				)							->							Dict:

										'''simple docstring'''




										snake_case_         = self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*a__				)




			@slow
			def   lowerCAmelCase__							(   self				)							->							Optional[Any]:

										'''simple docstring'''




										for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_         = TFLayoutLMModel.from_pretrained(a__				)
																	self.assertIsNotNone(a__				)




			@unittest.skip("Onnx compliancy broke with TF 2.10"				)
			def   lowerCAmelCase__							(   self				)							->							str:

										'''simple docstring'''




										pass


def 	UpperCamelCase_(      ):

							'''simple docstring'''






							snake_case_         = tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]	)  # noqa: E231
							snake_case_         = tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]	)  # noqa: E231
							snake_case_         = tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]	)  # noqa: E231
							snake_case_         = tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]	)  # noqa: E231
							# these are sequence labels (i.e. at the token level)
							snake_case_         = tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]	)  # noqa: E231
							# fmt: on

							return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class 					_snake_case						(      unittest.TestCase				):




			@slow
			def   lowerCAmelCase__							(   self				)							->							Dict:

										'''simple docstring'''




										snake_case_         = TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"				)

										snake_case_   , snake_case_   , snake_case_   , snake_case_   , snake_case_         = prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_         = model(input_ids=a__							,				bbox=a__							,				attention_mask=a__							,				token_type_ids=a__				)

										# test the sequence output on [0, :3, :3]
										snake_case_         = tf.convert_to_tensor(
										    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]]							,				)

										self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]							,				a__							,				atol=1e-3				)				)

										# test the pooled output on [1, :3]
										snake_case_         = tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]				)

										self.assertTrue(np.allclose(outputs.pooler_output[1, :3]							,				a__							,				atol=1e-3				)				)




			@slow
			def   lowerCAmelCase__							(   self				)							->							Union[str, Any]:

										'''simple docstring'''




										snake_case_         = TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"							,				num_labels=2				)

										snake_case_   , snake_case_   , snake_case_   , snake_case_   , snake_case_         = prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_         = model(
										    input_ids=a__							,				bbox=a__							,				attention_mask=a__							,				token_type_ids=a__							,				labels=tf.convert_to_tensor([1, 1]				)							,				)

										# test whether we get a loss as a scalar
										snake_case_         = outputs.loss
										snake_case_         = (2,)
										self.assertEqual(loss.shape							,				a__				)

										# test the shape of the logits
										snake_case_         = outputs.logits
										snake_case_         = (2, 2)
										self.assertEqual(logits.shape							,				a__				)




			@slow
			def   lowerCAmelCase__							(   self				)							->							Union[str, Any]:

										'''simple docstring'''




										snake_case_         = TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"							,				num_labels=13				)

										snake_case_   , snake_case_   , snake_case_   , snake_case_   , snake_case_         = prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_         = model(
										    input_ids=a__							,				bbox=a__							,				attention_mask=a__							,				token_type_ids=a__							,				labels=a__				)

										# test the shape of the logits
										snake_case_         = outputs.logits
										snake_case_         = tf.convert_to_tensor((2, 25, 13)				)
										self.assertEqual(logits.shape							,				a__				)




			@slow
			def   lowerCAmelCase__							(   self				)							->							int:

										'''simple docstring'''




										snake_case_         = TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"				)

										snake_case_   , snake_case_   , snake_case_   , snake_case_   , snake_case_         = prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_         = model(input_ids=a__							,				bbox=a__							,				attention_mask=a__							,				token_type_ids=a__				)

										# test the shape of the logits
										snake_case_         = tf.convert_to_tensor((2, 25)				)
										self.assertEqual(outputs.start_logits.shape							,				a__				)
										self.assertEqual(outputs.end_logits.shape							,				a__				)







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 					__lowerCAmelCase	(   SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     unittest.TestCase				):
  _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     A__	(							self   )    ->					List[Any]:
        '''simple docstring'''






        torch.manual_seed(0   )
        _lowercase      			=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=lowerCAmelCase				,  )
        _lowercase      			=DDIMScheduler(
            beta_start=0.00085				,  beta_end=0.012				,  beta_schedule='scaled_linear'				,  clip_sample=lowerCAmelCase				,  set_alpha_to_one=lowerCAmelCase				,  )
        _lowercase      			=DDIMInverseScheduler(
            beta_start=0.00085				,  beta_end=0.012				,  beta_schedule='scaled_linear'				,  clip_sample=lowerCAmelCase				,  set_alpha_to_zero=lowerCAmelCase				,  )
        torch.manual_seed(0   )
        _lowercase      			=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=128				,  )
        torch.manual_seed(0   )
        _lowercase      			=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=1_000				,  hidden_act='gelu'				,  projection_dim=512				,  )
        _lowercase      			=CLIPTextModel(lowerCAmelCase   )
        _lowercase      			=CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'   )

        _lowercase      			={
            '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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase=0   )    ->					Tuple:
        '''simple docstring'''






        _lowercase      			=floats_tensor((1, 16, 16)				,  rng=random.Random(lowerCAmelCase   )   ).to(lowerCAmelCase   )
        _lowercase      			=floats_tensor((1, 2, 4, 16, 16)				,  rng=random.Random(lowerCAmelCase   )   ).to(lowerCAmelCase   )
        if str(lowerCAmelCase   ).startswith('mps'   ):
              _lowercase      			=torch.manual_seed(lowerCAmelCase   )
        else:
              _lowercase      			=torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
        _lowercase      			={
            '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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase=0   )    ->					Optional[Any]:
        '''simple docstring'''






        _lowercase      			=floats_tensor((1, 3, 32, 32)				,  rng=random.Random(lowerCAmelCase   )   ).to(lowerCAmelCase   )
        _lowercase      			=image.cpu().permute(0				,  2				,  3				,  1   )[0]
        _lowercase      			=Image.fromarray(np.uinta(lowerCAmelCase   )   ).convert('RGB'   )
        if str(lowerCAmelCase   ).startswith('mps'   ):
              _lowercase      			=torch.manual_seed(lowerCAmelCase   )
        else:
              _lowercase      			=torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
        _lowercase      			={
            '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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase=0   )    ->					List[Any]:
        '''simple docstring'''






        _lowercase      			=floats_tensor((1, 3, 32, 32)				,  rng=random.Random(lowerCAmelCase   )   ).to(lowerCAmelCase   )
        _lowercase      			=image.cpu().permute(0				,  2				,  3				,  1   )[0]
        _lowercase      			=Image.fromarray(np.uinta(lowerCAmelCase   )   ).convert('RGB'   )
        if str(lowerCAmelCase   ).startswith('mps'   ):
              _lowercase      			=torch.manual_seed(lowerCAmelCase   )
        else:
              _lowercase      			=torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
        _lowercase      			={
            '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     A__	(							self   )    ->					Any:
        '''simple docstring'''






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

        _lowercase      			=self.get_dummy_components()
        _lowercase      			=self.pipeline_class(**lowerCAmelCase   )
        pipe.to(lowerCAmelCase   )
        pipe.set_progress_bar_config(disable=lowerCAmelCase   )

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

        _lowercase      			=self.get_dummy_inputs(lowerCAmelCase   )
        _lowercase      			=pipe(**lowerCAmelCase   )[0]

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

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

        _lowercase      			=self.get_dummy_inputs(lowerCAmelCase   )
        _lowercase      			=pipe_loaded(**lowerCAmelCase   )[0]

        _lowercase      			=np.abs(output - output_loaded   ).max()
        self.assertLess(lowerCAmelCase				,  1e-4   )




  def     A__	(							self   )    ->					int:
        '''simple docstring'''






        _lowercase      			='cpu'

        _lowercase      			=self.get_dummy_components()
        _lowercase      			=self.pipeline_class(**lowerCAmelCase   )
        pipe.to(lowerCAmelCase   )
        pipe.set_progress_bar_config(disable=lowerCAmelCase   )

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

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




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			='cpu'

        _lowercase      			=self.get_dummy_components()
        _lowercase      			=self.pipeline_class(**lowerCAmelCase   )
        pipe.to(lowerCAmelCase   )
        pipe.set_progress_bar_config(disable=lowerCAmelCase   )

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

        self.assertEqual(image.shape				,  (2, 32, 32, 3)   )
        _lowercase      			=np.array(
            [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]				,  )
        _lowercase      			=np.abs(image_slice.flatten() - expected_slice   ).max()
        self.assertLessEqual(lowerCAmelCase				,  1e-3   )




  def     A__	(							self   )    ->					List[Any]:
        '''simple docstring'''






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




  def     A__	(							self   )    ->					Any:
        '''simple docstring'''






        _lowercase      			='cpu'

        _lowercase      			=self.get_dummy_components()

        _lowercase      			={'beta_start': 0.00085, 'beta_end': 0.012, 'beta_schedule': 'scaled_linear'}
        _lowercase      			=DPMSolverMultistepScheduler(**lowerCAmelCase   )
        _lowercase      			=DPMSolverMultistepInverseScheduler(**lowerCAmelCase   )

        _lowercase      			=self.pipeline_class(**lowerCAmelCase   )
        pipe.to(lowerCAmelCase   )
        pipe.set_progress_bar_config(disable=lowerCAmelCase   )

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

        self.assertEqual(image.shape				,  (2, 32, 32, 3)   )
        _lowercase      			=np.array(
            [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]				,  )
        _lowercase      			=np.abs(image_slice.flatten() - expected_slice   ).max()
        self.assertLessEqual(lowerCAmelCase				,  1e-3   )





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




  def     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






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




  @classmethod
  def     A__	(							cls   )    ->					int:
        '''simple docstring'''






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

        _lowercase      			=raw_image.convert('RGB'   ).resize((768, 768)   )

        _lowercase      			=raw_image




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=torch.manual_seed(0   )

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

        _lowercase      			='a bowl of fruit'
        _lowercase      			='a bowl of pears'

        _lowercase      			=pipe.generate_mask(
            image=self.raw_image				,  source_prompt=lowerCAmelCase				,  target_prompt=lowerCAmelCase				,  generator=lowerCAmelCase				,  )

        _lowercase      			=pipe.invert(
            prompt=lowerCAmelCase				,  image=self.raw_image				,  inpaint_strength=0.7				,  generator=lowerCAmelCase   ).latents

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

        _lowercase      			=(
            np.array(
                load_image(
                    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                    '/diffedit/pears.png'   ).resize((768, 768)   )   )
            / 255
        )
        assert np.abs((expected_image - image).max()   ) < 5e-1




  def     A__	(							self   )    ->					Any:
        '''simple docstring'''






        _lowercase      			=torch.manual_seed(0   )

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

        _lowercase      			='a bowl of fruit'
        _lowercase      			='a bowl of pears'

        _lowercase      			=pipe.generate_mask(
            image=self.raw_image				,  source_prompt=lowerCAmelCase				,  target_prompt=lowerCAmelCase				,  generator=lowerCAmelCase				,  )

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

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

        _lowercase      			=(
            np.array(
                load_image(
                    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                    '/diffedit/pears.png'   ).resize((768, 768)   )   )
            / 255
        )
        assert np.abs((expected_image - image).max()   ) < 5e-1


