"""simple docstring"""





import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin
@skip_mps
class  _snake_case     (					a__				, a__				, unittest.TestCase		):
						snake_case__			  =			IFPipeline
						snake_case__			  =			TEXT_TO_IMAGE_PARAMS - {"width", "height", "latents"}
						snake_case__			  =			TEXT_TO_IMAGE_BATCH_PARAMS
						snake_case__			  =			PipelineTesterMixin.required_optional_params - {"latents"}






						def       lowerCamelCase__     (       self      :			Optional[int]    ):
													return self._get_dummy_components()






						def       lowerCamelCase__     (       self      :			Optional[Any]							,					UpperCAmelCase      :			Optional[Any]							,					UpperCAmelCase      :			List[str]=0    ):
													if str(UpperCAmelCase    ).startswith("mps"    ):
																				__lowerCamelCase					:		Union[str, Any]		   =     torch.manual_seed(UpperCAmelCase    )
													else:
																				__lowerCamelCase					:		Union[str, Any]		   =     torch.Generator(device=UpperCAmelCase    ).manual_seed(UpperCAmelCase    )

													__lowerCamelCase					:		Tuple		   =     {
													    "prompt": "A painting of a squirrel eating a burger",
													    "generator": generator,
													    "num_inference_steps": 2,
													    "output_type": "numpy",
													}

													return inputs






						def       lowerCamelCase__     (       self      :			int    ):
													self._test_save_load_optional_components()






						@unittest.skipIf(torch_device != "cuda"							,					reason="float16 requires CUDA"    )
						def       lowerCamelCase__     (       self      :			Optional[Any]    ):
													# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
													super().test_save_load_floataa(expected_max_diff=1E-1    )






						def       lowerCamelCase__     (       self      :			Optional[Any]    ):
													self._test_attention_slicing_forward_pass(expected_max_diff=1E-2    )






						def       lowerCamelCase__     (       self      :			Optional[Any]    ):
													self._test_save_load_local()






						def       lowerCamelCase__     (       self      :			Any    ):
													self._test_inference_batch_single_identical(
													    expected_max_diff=1E-2							,					)







						@unittest.skipIf(
						    torch_device != "cuda" or not is_xformers_available()							,					reason="XFormers attention is only available with CUDA and `xformers` installed"							,					)
						def       lowerCamelCase__     (       self      :			int    ):
													self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3    )

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






						def       lowerCamelCase__     (       self      :			Dict    ):
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()






						def       lowerCamelCase__     (       self      :			int    ):
													# if

													__lowerCamelCase					:		List[str]		   =     IFPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0"							,					variant="fp16"							,					torch_dtype=torch.floataa    )

													__lowerCamelCase					:		Tuple		   =     IFSuperResolutionPipeline.from_pretrained(
													    "DeepFloyd/IF-II-L-v1.0"							,					variant="fp16"							,					torch_dtype=torch.floataa							,					text_encoder=UpperCAmelCase							,					tokenizer=UpperCAmelCase    )

													# pre compute text embeddings and remove T5 to save memory

													pipe_a.text_encoder.to("cuda"    )

													__lowerCamelCase   ,  __lowerCamelCase					:		Any		   =     pipe_a.encode_prompt("anime turtle"							,					device="cuda"    )

													del pipe_a.tokenizer
													del pipe_a.text_encoder
													gc.collect()

													__lowerCamelCase					:		Any		   =     None
													__lowerCamelCase					:		Optional[int]		   =     None

													pipe_a.enable_model_cpu_offload()
													pipe_a.enable_model_cpu_offload()

													pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
													pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

													self._test_if(UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )

													pipe_a.remove_all_hooks()
													pipe_a.remove_all_hooks()

													# img2img

													__lowerCamelCase					:		Tuple		   =     IFImgaImgPipeline(**pipe_a.components    )
													__lowerCamelCase					:		Union[str, Any]		   =     IFImgaImgSuperResolutionPipeline(**pipe_a.components    )

													pipe_a.enable_model_cpu_offload()
													pipe_a.enable_model_cpu_offload()

													pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
													pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

													self._test_if_imgaimg(UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )

													pipe_a.remove_all_hooks()
													pipe_a.remove_all_hooks()

													# inpainting

													__lowerCamelCase					:		List[str]		   =     IFInpaintingPipeline(**pipe_a.components    )
													__lowerCamelCase					:		Union[str, Any]		   =     IFInpaintingSuperResolutionPipeline(**pipe_a.components    )

													pipe_a.enable_model_cpu_offload()
													pipe_a.enable_model_cpu_offload()

													pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )
													pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()    )

													self._test_if_inpainting(UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			Optional[int]							,					UpperCAmelCase      :			Tuple							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			Any    ):
													# pipeline 1

													_start_torch_memory_measurement()

													__lowerCamelCase					:		List[str]		   =     torch.Generator(device="cpu"    ).manual_seed(0    )
													__lowerCamelCase					:		Union[str, Any]		   =     pipe_a(
													    prompt_embeds=UpperCAmelCase							,					negative_prompt_embeds=UpperCAmelCase							,					num_inference_steps=2							,					generator=UpperCAmelCase							,					output_type="np"							,					)

													__lowerCamelCase					:		List[Any]		   =     output.images[0]

													assert image.shape == (64, 64, 3)

													__lowerCamelCase					:		Any		   =     torch.cuda.max_memory_allocated()
													assert mem_bytes < 13 * 10**9

													__lowerCamelCase					:		str		   =     load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy"    )
													assert_mean_pixel_difference(UpperCAmelCase							,					UpperCAmelCase    )

													# pipeline 2

													_start_torch_memory_measurement()

													__lowerCamelCase					:		Any		   =     torch.Generator(device="cpu"    ).manual_seed(0    )

													__lowerCamelCase					:		Tuple		   =     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(UpperCAmelCase    )

													__lowerCamelCase					:		int		   =     pipe_a(
													    prompt_embeds=UpperCAmelCase							,					negative_prompt_embeds=UpperCAmelCase							,					image=UpperCAmelCase							,					generator=UpperCAmelCase							,					num_inference_steps=2							,					output_type="np"							,					)

													__lowerCamelCase					:		Tuple		   =     output.images[0]

													assert image.shape == (256, 256, 3)

													__lowerCamelCase					:		int		   =     torch.cuda.max_memory_allocated()
													assert mem_bytes < 4 * 10**9

													__lowerCamelCase					:		List[str]		   =     load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy"    )
													assert_mean_pixel_difference(UpperCAmelCase							,					UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			Union[str, Any]							,					UpperCAmelCase      :			str							,					UpperCAmelCase      :			List[str]							,					UpperCAmelCase      :			Dict							,					UpperCAmelCase      :			List[str]    ):
													# pipeline 1

													_start_torch_memory_measurement()

													__lowerCamelCase					:		Optional[int]		   =     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(UpperCAmelCase    )

													__lowerCamelCase					:		Tuple		   =     torch.Generator(device="cpu"    ).manual_seed(0    )

													__lowerCamelCase					:		List[str]		   =     pipe_a(
													    prompt_embeds=UpperCAmelCase							,					negative_prompt_embeds=UpperCAmelCase							,					image=UpperCAmelCase							,					num_inference_steps=2							,					generator=UpperCAmelCase							,					output_type="np"							,					)

													__lowerCamelCase					:		Optional[Any]		   =     output.images[0]

													assert image.shape == (64, 64, 3)

													__lowerCamelCase					:		List[Any]		   =     torch.cuda.max_memory_allocated()
													assert mem_bytes < 10 * 10**9

													__lowerCamelCase					:		Optional[Any]		   =     load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy"    )
													assert_mean_pixel_difference(UpperCAmelCase							,					UpperCAmelCase    )

													# pipeline 2

													_start_torch_memory_measurement()

													__lowerCamelCase					:		int		   =     torch.Generator(device="cpu"    ).manual_seed(0    )

													__lowerCamelCase					:		int		   =     floats_tensor((1, 3, 256, 256)							,					rng=random.Random(0    )    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		List[str]		   =     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(UpperCAmelCase    )

													__lowerCamelCase					:		Dict		   =     pipe_a(
													    prompt_embeds=UpperCAmelCase							,					negative_prompt_embeds=UpperCAmelCase							,					image=UpperCAmelCase							,					original_image=UpperCAmelCase							,					generator=UpperCAmelCase							,					num_inference_steps=2							,					output_type="np"							,					)

													__lowerCamelCase					:		List[Any]		   =     output.images[0]

													assert image.shape == (256, 256, 3)

													__lowerCamelCase					:		List[Any]		   =     torch.cuda.max_memory_allocated()
													assert mem_bytes < 4 * 10**9

													__lowerCamelCase					:		Any		   =     load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy"    )
													assert_mean_pixel_difference(UpperCAmelCase							,					UpperCAmelCase    )







						def       lowerCamelCase__     (       self      :			Tuple							,					UpperCAmelCase      :			List[str]							,					UpperCAmelCase      :			str							,					UpperCAmelCase      :			Tuple							,					UpperCAmelCase      :			Dict    ):
													# pipeline 1

													_start_torch_memory_measurement()

													__lowerCamelCase					:		Optional[int]		   =     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		str		   =     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(1    )    ).to(UpperCAmelCase    )

													__lowerCamelCase					:		List[str]		   =     torch.Generator(device="cpu"    ).manual_seed(0    )
													__lowerCamelCase					:		List[Any]		   =     pipe_a(
													    prompt_embeds=UpperCAmelCase							,					negative_prompt_embeds=UpperCAmelCase							,					image=UpperCAmelCase							,					mask_image=UpperCAmelCase							,					num_inference_steps=2							,					generator=UpperCAmelCase							,					output_type="np"							,					)

													__lowerCamelCase					:		Dict		   =     output.images[0]

													assert image.shape == (64, 64, 3)

													__lowerCamelCase					:		Any		   =     torch.cuda.max_memory_allocated()
													assert mem_bytes < 10 * 10**9

													__lowerCamelCase					:		List[Any]		   =     load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy"    )
													assert_mean_pixel_difference(UpperCAmelCase							,					UpperCAmelCase    )

													# pipeline 2

													_start_torch_memory_measurement()

													__lowerCamelCase					:		Dict		   =     torch.Generator(device="cpu"    ).manual_seed(0    )

													__lowerCamelCase					:		Dict		   =     floats_tensor((1, 3, 64, 64)							,					rng=random.Random(0    )    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		Optional[int]		   =     floats_tensor((1, 3, 256, 256)							,					rng=random.Random(0    )    ).to(UpperCAmelCase    )
													__lowerCamelCase					:		Union[str, Any]		   =     floats_tensor((1, 3, 256, 256)							,					rng=random.Random(1    )    ).to(UpperCAmelCase    )

													__lowerCamelCase					:		Dict		   =     pipe_a(
													    prompt_embeds=UpperCAmelCase							,					negative_prompt_embeds=UpperCAmelCase							,					image=UpperCAmelCase							,					mask_image=UpperCAmelCase							,					original_image=UpperCAmelCase							,					generator=UpperCAmelCase							,					num_inference_steps=2							,					output_type="np"							,					)

													__lowerCamelCase					:		int		   =     output.images[0]

													assert image.shape == (256, 256, 3)

													__lowerCamelCase					:		Dict		   =     torch.cuda.max_memory_allocated()
													assert mem_bytes < 4 * 10**9

													__lowerCamelCase					:		Any		   =     load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy"    )
													assert_mean_pixel_difference(UpperCAmelCase							,					UpperCAmelCase    )


def    lowercase_   (   ) ->      int:



							'''simple docstring'''

							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()
"""simple docstring"""





from __future__ import annotations


def    lowercase_   (   _lowerCamelCase:	list[list[int]]      ) ->      bool:



							'''simple docstring'''

							__lowerCamelCase					:		str		   =     len(_lowerCamelCase      )
							# We need to create solution object to save path.
							__lowerCamelCase					:		List[Any]		   =     [[0 for _ in range(_lowerCamelCase      )] for _ in range(_lowerCamelCase      )]
							__lowerCamelCase					:		Dict		   =     run_maze(_lowerCamelCase						,   0						,   0						,   _lowerCamelCase      )
							if solved:
														print("\n".join(str(_lowerCamelCase      ) for row in solutions      )      )
							else:
														print("No solution exists!"      )
							return solved


def    lowercase_   (   _lowerCamelCase:	list[list[int]]						,   _lowerCamelCase:	int						,   _lowerCamelCase:	int						,   _lowerCamelCase:	list[list[int]]      ) ->      bool:



							'''simple docstring'''

							__lowerCamelCase					:		Dict		   =     len(_lowerCamelCase      )
							# Final check point.
							if i == j == (size - 1):
														__lowerCamelCase					:		Optional[Any]		   =     1
														return True

							__lowerCamelCase					:		int		   =     (not i < 0) and (not j < 0)  # Check lower bounds
							__lowerCamelCase					:		Union[str, Any]		   =     (i < size) and (j < size)  # Check upper bounds

							if lower_flag and upper_flag:
														# check for already visited and block points.
														__lowerCamelCase					:		List[Any]		   =     (not solutions[i][j]) and (not maze[i][j])
														if block_flag:
																					# check visited
																					__lowerCamelCase					:		Dict		   =     1

																					# check for directions
																					if (
																					    run_maze(_lowerCamelCase						,   i + 1						,   _lowerCamelCase						,   _lowerCamelCase      )
																					    or run_maze(_lowerCamelCase						,   _lowerCamelCase						,   j + 1						,   _lowerCamelCase      )
																					    or run_maze(_lowerCamelCase						,   i - 1						,   _lowerCamelCase						,   _lowerCamelCase      )
																					    or run_maze(_lowerCamelCase						,   _lowerCamelCase						,   j - 1						,   _lowerCamelCase      )
																					):
																												return True

																					__lowerCamelCase					:		List[str]		   =     0
																					return False
							return False


if __name__ == "__main__":
				import doctest

				doctest.testmod()