

import argparse

import torch

from transformers import (
    SpeechTaConfig,
    SpeechTaFeatureExtractor,
    SpeechTaForSpeechToSpeech,
    SpeechTaForSpeechToText,
    SpeechTaForTextToSpeech,
    SpeechTaProcessor,
    SpeechTaTokenizer,
    logging,
)
from transformers.tokenization_utils import AddedToken


logging.set_verbosity_info()
a_      =     logging.get_logger('transformers.models.speecht5')

a_      =     {
    'speech_encoder_prenet.layer_norm': 'speecht5.encoder.prenet.feature_projection.layer_norm',
    'speech_encoder_prenet.post_extract_proj': 'speecht5.encoder.prenet.feature_projection.projection',
    'speech_encoder_prenet.pos_conv.0': 'speecht5.encoder.prenet.pos_conv_embed.conv',
    'speech_encoder_prenet.mask_emb': 'speecht5.encoder.prenet.masked_spec_embed',
}
a_      =     {
    'text_encoder_prenet.encoder_prenet.0': 'speecht5.encoder.prenet.embed_tokens',
    'text_encoder_prenet.encoder_prenet.1.alpha': 'speecht5.encoder.prenet.encode_positions.alpha',
}
a_      =     {
    'speech_decoder_prenet.decoder_prenet.0.0.prenet.0.0': 'speecht5.decoder.prenet.layers.0',
    'speech_decoder_prenet.decoder_prenet.0.0.prenet.1.0': 'speecht5.decoder.prenet.layers.1',
    'speech_decoder_prenet.decoder_prenet.0.1': 'speecht5.decoder.prenet.final_layer',
    'speech_decoder_prenet.decoder_prenet.1.alpha': 'speecht5.decoder.prenet.encode_positions.alpha',
    'speech_decoder_prenet.spkembs_layer.0': 'speecht5.decoder.prenet.speaker_embeds_layer',
}
a_      =     {
    'speech_decoder_postnet.feat_out': 'speech_decoder_postnet.feat_out',
    'speech_decoder_postnet.prob_out': 'speech_decoder_postnet.prob_out',
    'speech_decoder_postnet.postnet.postnet.0.0': 'speech_decoder_postnet.layers.0.conv',
    'speech_decoder_postnet.postnet.postnet.0.1': 'speech_decoder_postnet.layers.0.batch_norm',
    'speech_decoder_postnet.postnet.postnet.1.0': 'speech_decoder_postnet.layers.1.conv',
    'speech_decoder_postnet.postnet.postnet.1.1': 'speech_decoder_postnet.layers.1.batch_norm',
    'speech_decoder_postnet.postnet.postnet.2.0': 'speech_decoder_postnet.layers.2.conv',
    'speech_decoder_postnet.postnet.postnet.2.1': 'speech_decoder_postnet.layers.2.batch_norm',
    'speech_decoder_postnet.postnet.postnet.3.0': 'speech_decoder_postnet.layers.3.conv',
    'speech_decoder_postnet.postnet.postnet.3.1': 'speech_decoder_postnet.layers.3.batch_norm',
    'speech_decoder_postnet.postnet.postnet.4.0': 'speech_decoder_postnet.layers.4.conv',
    'speech_decoder_postnet.postnet.postnet.4.1': 'speech_decoder_postnet.layers.4.batch_norm',
}
a_      =     {
    'text_decoder_prenet.embed_tokens': 'speecht5.decoder.prenet.embed_tokens',
}
a_      =     {
    'text_decoder_postnet.output_projection': 'text_decoder_postnet.lm_head',
}
a_      =     {
    'encoder.layers.*.self_attn.k_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.k_proj',
    'encoder.layers.*.self_attn.v_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.v_proj',
    'encoder.layers.*.self_attn.q_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.q_proj',
    'encoder.layers.*.self_attn.out_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.out_proj',
    'encoder.layers.*.self_attn_layer_norm': 'speecht5.encoder.wrapped_encoder.layers.*.layer_norm',
    'encoder.layers.*.fc1': 'speecht5.encoder.wrapped_encoder.layers.*.feed_forward.intermediate_dense',
    'encoder.layers.*.fc2': 'speecht5.encoder.wrapped_encoder.layers.*.feed_forward.output_dense',
    'encoder.layers.*.final_layer_norm': 'speecht5.encoder.wrapped_encoder.layers.*.final_layer_norm',
    'encoder.layer_norm': 'speecht5.encoder.wrapped_encoder.layer_norm',
    'encoder.pos_emb.pe_k': 'speecht5.encoder.wrapped_encoder.embed_positions.pe_k',
}
a_      =     {
    'decoder.layers.*.self_attn.k_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.k_proj',
    'decoder.layers.*.self_attn.v_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.v_proj',
    'decoder.layers.*.self_attn.q_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.q_proj',
    'decoder.layers.*.self_attn.out_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.out_proj',
    'decoder.layers.*.self_attn_layer_norm': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn_layer_norm',
    'decoder.layers.*.encoder_attn.k_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.k_proj',
    'decoder.layers.*.encoder_attn.v_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.v_proj',
    'decoder.layers.*.encoder_attn.q_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.q_proj',
    'decoder.layers.*.encoder_attn.out_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.out_proj',
    'decoder.layers.*.encoder_attn_layer_norm': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn_layer_norm',
    'decoder.layers.*.fc1': 'speecht5.decoder.wrapped_decoder.layers.*.feed_forward.intermediate_dense',
    'decoder.layers.*.fc2': 'speecht5.decoder.wrapped_decoder.layers.*.feed_forward.output_dense',
    'decoder.layers.*.final_layer_norm': 'speecht5.decoder.wrapped_decoder.layers.*.final_layer_norm',
}
a_      =     {
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_TEXT_DECODER_PRENET,
    **MAPPING_TEXT_DECODER_POSTNET,
}
a_      =     {
    **MAPPING_TEXT_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
a_      =     {
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
a_      =     []
a_      =     [
    'encoder.version',
    'encoder.layers.*.norm_k.weight',
    'encoder.layers.*.norm_k.bias',
    'decoder.version',
    'decoder.layers.*.norm_k.weight',
    'decoder.layers.*.norm_k.bias',
    'decoder.pos_emb.pe_k',
    'speech_encoder_prenet.embed_positions._float_tensor',
    'text_decoder_prenet.embed_positions._float_tensor',
]
a_      =     IGNORE_KEYS + [
    'encoder.proj',
    'text_encoder_prenet.*',
    'speech_decoder_prenet.*',
    'speech_decoder_postnet.*',
]
a_      =     IGNORE_KEYS + [
    'encoder.proj',
    'speech_encoder_prenet.*',
    'text_decoder_prenet.*',
    'text_decoder_postnet.*',
]
a_      =     IGNORE_KEYS + [
    'encoder.proj',
    'text_encoder_prenet.*',
    'text_decoder_prenet.*',
    'text_decoder_postnet.*',
]

def 			lowerCamelCase__			(       _a				,      _a				,      _a				,      _a				,      _a):
	for attribute in key.split("."):
		SCREAMING_SNAKE_CASE :   Any					  =							getattr(_a				,      _a)

	if weight_type is not None:
		SCREAMING_SNAKE_CASE :   str					  =							getattr(_a				,      _a).shape
	else:
		SCREAMING_SNAKE_CASE :   Dict					  =							hf_pointer.shape

	if hf_shape != value.shape:
		raise ValueError(
		    f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
		    f" {value.shape} for {full_name}")

	if weight_type == "weight":
		SCREAMING_SNAKE_CASE :   List[str]					  =							value
	elif weight_type == "weight_g":
		SCREAMING_SNAKE_CASE :   Optional[int]					  =							value
	elif weight_type == "weight_v":
		SCREAMING_SNAKE_CASE :   int					  =							value
	elif weight_type == "bias":
		SCREAMING_SNAKE_CASE :   Tuple					  =							value
	elif weight_type == "running_mean":
		SCREAMING_SNAKE_CASE :   Dict					  =							value
	elif weight_type == "running_var":
		SCREAMING_SNAKE_CASE :   Any					  =							value
	elif weight_type == "num_batches_tracked":
		SCREAMING_SNAKE_CASE :   Dict					  =							value
	else:
		SCREAMING_SNAKE_CASE :   int					  =							value

	logger.info(f"{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}.")

def 			lowerCamelCase__			(       _a				,      _a):
	for key in ignore_keys:
		if key.endswith(".*"):
			if name.startswith(key[:-1]):
				return True
		elif ".*." in key:
			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE :   int					  =							key.split(".*.")
			if prefix in name and suffix in name:
				return True
		elif key in name:
			return True
	return False

def 			lowerCamelCase__			(       _a				,      _a				,      _a):
	SCREAMING_SNAKE_CASE :   List[str]					  =							[]

	if task == "s2t":
		SCREAMING_SNAKE_CASE :   List[Any]					  =							hf_model.speechta.encoder.prenet.feature_encoder
		SCREAMING_SNAKE_CASE :   Optional[int]					  =							MAPPING_S2T
		SCREAMING_SNAKE_CASE :   Any					  =							IGNORE_KEYS_S2T
	elif task == "t2s":
		SCREAMING_SNAKE_CASE :   Any					  =							None
		SCREAMING_SNAKE_CASE :   Optional[Any]					  =							MAPPING_T2S
		SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							IGNORE_KEYS_T2S
	elif task == "s2s":
		SCREAMING_SNAKE_CASE :   List[Any]					  =							hf_model.speechta.encoder.prenet.feature_encoder
		SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							MAPPING_S2S
		SCREAMING_SNAKE_CASE :   str					  =							IGNORE_KEYS_S2S
	else:
		raise ValueError(f"Unsupported task: {task}")

	for name, value in fairseq_dict.items():
		if should_ignore(_a				,      _a):
			logger.info(f"{name} was ignored")
			continue

		SCREAMING_SNAKE_CASE :   Tuple					  =							False
		if "conv_layers" in name:
			load_conv_layer(
			    _a				,      _a				,      _a				,      _a				,      hf_model.config.feat_extract_norm == "group"				,      )
			SCREAMING_SNAKE_CASE :   Tuple					  =							True
		else:
			for key, mapped_key in MAPPING.items():
				# mapped_key = "speecht5." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key

				if "*" in key:
					SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE :   Dict					  =							key.split(".*.")
					if prefix in name and suffix in name:
						SCREAMING_SNAKE_CASE :   str					  =							suffix

                # if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
				if key in name:
					SCREAMING_SNAKE_CASE :   int					  =							True
					if "*" in mapped_key:
						SCREAMING_SNAKE_CASE :   Dict					  =							name.split(_a)[0].split(".")[-2]
						SCREAMING_SNAKE_CASE :   Optional[int]					  =							mapped_key.replace("*"				,      _a)
					if "weight_g" in name:
						SCREAMING_SNAKE_CASE :   str					  =							"weight_g"
					elif "weight_v" in name:
						SCREAMING_SNAKE_CASE :   List[Any]					  =							"weight_v"
					elif "bias" in name:
						SCREAMING_SNAKE_CASE :   Optional[int]					  =							"bias"
					elif "weight" in name:
						SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							"weight"
					elif "running_mean" in name:
						SCREAMING_SNAKE_CASE :   Any					  =							"running_mean"
					elif "running_var" in name:
						SCREAMING_SNAKE_CASE :   Tuple					  =							"running_var"
					elif "num_batches_tracked" in name:
						SCREAMING_SNAKE_CASE :   Dict					  =							"num_batches_tracked"
					else:
						SCREAMING_SNAKE_CASE :   Optional[int]					  =							None
					set_recursively(_a				,      _a				,      _a				,      _a				,      _a)
				continue
		if not is_used:
			unused_weights.append(_a)

	logger.warning(f"Unused weights: {unused_weights}")

def 			lowerCamelCase__			(       _a				,      _a				,      _a				,      _a				,      _a):
	SCREAMING_SNAKE_CASE :   Optional[Any]					  =							full_name.split("conv_layers.")[-1]
	SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							name.split(".")
	SCREAMING_SNAKE_CASE :   Dict					  =							int(items[0])
	SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							int(items[1])

	if type_id == 0:
		if "bias" in name:
			if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
				raise ValueError(
				    f"{full_name} has size {value.shape}, but"
				    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.")
			SCREAMING_SNAKE_CASE :   Optional[Any]					  =							value
			logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
		elif "weight" in name:
			if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
				raise ValueError(
				    f"{full_name} has size {value.shape}, but"
				    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.")
			SCREAMING_SNAKE_CASE :   List[str]					  =							value
			logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}.")
	elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
		if "bias" in name:
			if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
				raise ValueError(
				    f"{full_name} has size {value.shape}, but"
				    f" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found.")
			SCREAMING_SNAKE_CASE :   List[Any]					  =							value
			logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
		elif "weight" in name:
			if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
				raise ValueError(
				    f"{full_name} has size {value.shape}, but"
				    f" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found.")
			SCREAMING_SNAKE_CASE :   List[str]					  =							value
			logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.")
	else:
		unused_weights.append(_a)

@torch.no_grad()
def 			lowerCamelCase__			(       _a				,      _a				,      _a				,      _a=None				,      _a=None				,      _a=None				,      ):
	if config_path is not None:
		SCREAMING_SNAKE_CASE :   int					  =							SpeechTaConfig.from_pretrained(_a)
	else:
		SCREAMING_SNAKE_CASE :   Tuple					  =							SpeechTaConfig()

	if task == "s2t":
		SCREAMING_SNAKE_CASE :   int					  =							config.max_text_positions
		SCREAMING_SNAKE_CASE :   Optional[Any]					  =							SpeechTaForSpeechToText(_a)
	elif task == "t2s":
		SCREAMING_SNAKE_CASE :   Any					  =							1876
		SCREAMING_SNAKE_CASE :   Dict					  =							600
		SCREAMING_SNAKE_CASE :   Tuple					  =							config.max_speech_positions
		SCREAMING_SNAKE_CASE :   Optional[Any]					  =							SpeechTaForTextToSpeech(_a)
	elif task == "s2s":
		SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							1876
		SCREAMING_SNAKE_CASE :   Tuple					  =							config.max_speech_positions
		SCREAMING_SNAKE_CASE :   int					  =							SpeechTaForSpeechToSpeech(_a)
	else:
		raise ValueError(f"Unknown task name: {task}")

	if vocab_path:
		SCREAMING_SNAKE_CASE :   List[str]					  =							SpeechTaTokenizer(_a				,      model_max_length=config.max_text_positions)

		# Mask token behaves like a normal word, i.e. include the space before it
		SCREAMING_SNAKE_CASE :   Optional[int]					  =							AddedToken("<mask>"				,      lstrip=_a				,      rstrip=_a)
		SCREAMING_SNAKE_CASE :   Tuple					  =							mask_token
		tokenizer.add_special_tokens({"mask_token": mask_token})
		tokenizer.add_tokens(["<ctc_blank>"])

	SCREAMING_SNAKE_CASE :   Optional[int]					  =							SpeechTaFeatureExtractor()
	SCREAMING_SNAKE_CASE :   int					  =							SpeechTaProcessor(tokenizer=_a				,      feature_extractor=_a)
	processor.save_pretrained(_a)

	SCREAMING_SNAKE_CASE :   List[Any]					  =							torch.load(_a)
	recursively_load_weights(fairseq_checkpoint["model"]				,      _a				,      _a)

	model.save_pretrained(_a)

	if repo_id:
		print("Pushing to the hub...")
		processor.push_to_hub(_a)
		model.push_to_hub(_a)


if __name__ == "__main__":
			a_      =     argparse.ArgumentParser()
			parser.add_argument(
			    '--task',
			    default='s2t',
			    type=str,
			    help='Type of the SpeechT5 model you\'d like to convert. Should be one of \'s2t\', \'t2s\', \'s2s\'.',
			)
			parser.add_argument('--checkpoint_path', required=True, default=None, type=str, help='Path to fairseq checkpoint')
			parser.add_argument('--vocab_path', default=None, type=str, help='Path to SentencePiece model')
			parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
			parser.add_argument(
			    '--pytorch_dump_folder_path', required=True, default=None, type=str, help='Path to the output PyTorch model.'
			)
			parser.add_argument(
			    '--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
			)

			a_      =     parser.parse_args()
			convert_speechta_checkpoint(
			    args.task,
			    args.checkpoint_path,
			    args.pytorch_dump_folder_path,
			    args.config_path,
			    args.vocab_path,
			    args.push_to_hub,
			)


import unittest

import numpy as np

from diffusers import LMSDiscreteScheduler, OnnxStableDiffusionInpaintPipeline
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
			import onnxruntime as ort






class _UpperCamelCase				(				__A				,						unittest.TestCase ):
			'''simple docstring'''







			pass






@nightly
@require_onnxruntime
@require_torch_gpu
class _UpperCamelCase				(				unittest.TestCase ):
			'''simple docstring'''







			@property
			def 				__UpperCamelCase			(      self				:			List[Any]						)				->							List[str]:

				"""simple docstring"""

				return (
				    "CUDAExecutionProvider",
				    {
				        "gpu_mem_limit": "15000000000",  # 15GB
				        "arena_extend_strategy": "kSameAsRequested",
				    },
				)
			@property
			def 				__UpperCamelCase			(      self				:			int						)				->							Optional[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   Optional[Any]					  =							ort.SessionOptions()
				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							False
				return options
			def 				__UpperCamelCase			(      self				:			List[Any]						)				->							List[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   Any					  =							load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/in_paint/overture-creations-5sI6fQgYIuo.png"						)
				SCREAMING_SNAKE_CASE :   Optional[Any]					  =							load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/in_paint/overture-creations-5sI6fQgYIuo_mask.png"						)
				SCREAMING_SNAKE_CASE :   int					  =							OnnxStableDiffusionInpaintPipeline.from_pretrained(
				    "runwayml/stable-diffusion-inpainting"   ,   revision="onnx"   ,   safety_checker=a   ,   feature_extractor=a   ,   provider=self.gpu_provider   ,   sess_options=self.gpu_options   ,   )
				pipe.set_progress_bar_config(disable=a						)

				SCREAMING_SNAKE_CASE :   Optional[Any]					  =							"A red cat sitting on a park bench"

				SCREAMING_SNAKE_CASE :   Tuple					  =							np.random.RandomState(0						)
				SCREAMING_SNAKE_CASE :   Optional[int]					  =							pipe(
				    prompt=a   ,   image=a   ,   mask_image=a   ,   guidance_scale=7.5   ,   num_inference_steps=10   ,   generator=a   ,   output_type="np"   ,   )
				SCREAMING_SNAKE_CASE :   List[Any]					  =							output.images
				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							images[0, 255:258, 255:258, -1]

				assert images.shape == (1, 512, 512, 3)
				SCREAMING_SNAKE_CASE :   int					  =							np.array([0.2514, 0.3007, 0.3517, 0.1790, 0.2382, 0.3167, 0.1944, 0.2273, 0.2464]						)

				assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3






			def 				__UpperCamelCase			(      self				:			List[Any]						)				->							Tuple:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE :   int					  =							load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/in_paint/overture-creations-5sI6fQgYIuo.png"						)
				SCREAMING_SNAKE_CASE :   Optional[Any]					  =							load_image(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
				    "/in_paint/overture-creations-5sI6fQgYIuo_mask.png"						)
				SCREAMING_SNAKE_CASE :   Optional[Any]					  =							LMSDiscreteScheduler.from_pretrained(
				    "runwayml/stable-diffusion-inpainting"   ,   subfolder="scheduler"   ,   revision="onnx"						)
				SCREAMING_SNAKE_CASE :   Union[str, Any]					  =							OnnxStableDiffusionInpaintPipeline.from_pretrained(
				    "runwayml/stable-diffusion-inpainting"   ,   revision="onnx"   ,   scheduler=a   ,   safety_checker=a   ,   feature_extractor=a   ,   provider=self.gpu_provider   ,   sess_options=self.gpu_options   ,   )
				pipe.set_progress_bar_config(disable=a						)

				SCREAMING_SNAKE_CASE :   List[Any]					  =							"A red cat sitting on a park bench"

				SCREAMING_SNAKE_CASE :   Dict					  =							np.random.RandomState(0						)
				SCREAMING_SNAKE_CASE :   Tuple					  =							pipe(
				    prompt=a   ,   image=a   ,   mask_image=a   ,   guidance_scale=7.5   ,   num_inference_steps=20   ,   generator=a   ,   output_type="np"   ,   )
				SCREAMING_SNAKE_CASE :   List[str]					  =							output.images
				SCREAMING_SNAKE_CASE :   Optional[int]					  =							images[0, 255:258, 255:258, -1]

				assert images.shape == (1, 512, 512, 3)
				SCREAMING_SNAKE_CASE :   Any					  =							np.array([0.0086, 0.0077, 0.0083, 0.0093, 0.0107, 0.0139, 0.0094, 0.0097, 0.0125]						)

				assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3