


'''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 			a       (	_a			,						_a			,						unittest.TestCase ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE :				List[Any]							     =     IFPipeline
     SCREAMING_SNAKE_CASE :				str							     =     TEXT_TO_IMAGE_PARAMS - {"width", "height", "latents"}
     SCREAMING_SNAKE_CASE :				Any							     =     TEXT_TO_IMAGE_BATCH_PARAMS
     SCREAMING_SNAKE_CASE :				Optional[Any]							     =     PipelineTesterMixin.required_optional_params - {"latents"}

     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							Any:
          return self._get_dummy_components()

     def 				lowerCamelCase__				(       self  :	Any							,				snake_case  :	Optional[Any]							,				snake_case  :	Optional[Any]=0    )		->							str:
          if str(snake_case    ).startswith('''mps'''    ):
               __UpperCAmelCase			:				int													=    torch.manual_seed(snake_case    )
          else:
               __UpperCAmelCase			:				List[Any]													=    torch.Generator(device=snake_case    ).manual_seed(snake_case    )

          __UpperCAmelCase			:				List[Any]													=    {
              '''prompt''': '''A painting of a squirrel eating a burger''',
              '''generator''': generator,
              '''num_inference_steps''': 2,
              '''output_type''': '''numpy''',
          }

          return inputs

     def 				lowerCamelCase__				(       self  :	Optional[Any]    )		->							str:
          self._test_save_load_optional_components()

     @unittest.skipIf(torch_device != '''cuda'''							,				reason='''float16 requires CUDA'''    )
     def 				lowerCamelCase__				(       self  :	List[str]    )		->							Union[str, 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]    )		->							Dict:
          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2    )

     def 				lowerCamelCase__				(       self  :	Any    )		->							Any:
          self._test_save_load_local()

     def 				lowerCamelCase__				(       self  :	Tuple    )		->							Dict:
          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  :	Optional[Any]    )		->							List[Any]:
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3    )



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


     """simple docstring"""






     def 				lowerCamelCase__				(       self  :	Union[str, Any]    )		->							List[str]:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()

     def 				lowerCamelCase__				(       self  :	List[Any]    )		->							List[Any]:
          # if

          __UpperCAmelCase			:				Optional[Any]													=    IFPipeline.from_pretrained('''DeepFloyd/IF-I-XL-v1.0'''							,				variant='''fp16'''							,				torch_dtype=torch.floataa    )

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

          # pre compute text embeddings and remove T5 to save memory

          pipe_a.text_encoder.to('''cuda'''    )

          __UpperCAmelCase			:				str													=    pipe_a.encode_prompt('''anime turtle'''							,				device='''cuda'''    )

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

          __UpperCAmelCase			:				Dict													=    None
          __UpperCAmelCase			:				Any													=    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(snake_case							,				snake_case							,				snake_case							,				snake_case    )

          pipe_a.remove_all_hooks()
          pipe_a.remove_all_hooks()

          # img2img

          __UpperCAmelCase			:				List[Any]													=    IFImgaImgPipeline(**pipe_a.components    )
          __UpperCAmelCase			:				int													=    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(snake_case							,				snake_case							,				snake_case							,				snake_case    )

          pipe_a.remove_all_hooks()
          pipe_a.remove_all_hooks()

          # inpainting

          __UpperCAmelCase			:				Any													=    IFInpaintingPipeline(**pipe_a.components    )
          __UpperCAmelCase			:				str													=    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(snake_case							,				snake_case							,				snake_case							,				snake_case    )

     def 				lowerCamelCase__				(       self  :	Any							,				snake_case  :	Dict							,				snake_case  :	Tuple							,				snake_case  :	Optional[int]							,				snake_case  :	str    )		->							Tuple:
          # pipeline 1

          _start_torch_memory_measurement()

          __UpperCAmelCase			:				Dict													=    torch.Generator(device='''cpu'''    ).manual_seed(0    )
          __UpperCAmelCase			:				str													=    pipe_a(
              prompt_embeds=snake_case							,				negative_prompt_embeds=snake_case							,				num_inference_steps=2							,				generator=snake_case							,				output_type='''np'''							,				)

          __UpperCAmelCase			:				str													=    output.images[0]

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

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

          __UpperCAmelCase			:				Tuple													=    load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy'''    )
          assert_mean_pixel_difference(snake_case							,				snake_case    )

          # pipeline 2

          _start_torch_memory_measurement()

          __UpperCAmelCase			:				Union[str, Any]													=    torch.Generator(device='''cpu'''    ).manual_seed(0    )

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

          __UpperCAmelCase			:				int													=    pipe_a(
              prompt_embeds=snake_case							,				negative_prompt_embeds=snake_case							,				image=snake_case							,				generator=snake_case							,				num_inference_steps=2							,				output_type='''np'''							,				)

          __UpperCAmelCase			:				Optional[int]													=    output.images[0]

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

          __UpperCAmelCase			:				Union[str, Any]													=    torch.cuda.max_memory_allocated()
          assert mem_bytes < 4 * 10**9

          __UpperCAmelCase			:				List[Any]													=    load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'''    )
          assert_mean_pixel_difference(snake_case							,				snake_case    )

     def 				lowerCamelCase__				(       self  :	Tuple							,				snake_case  :	Any							,				snake_case  :	Optional[Any]							,				snake_case  :	str							,				snake_case  :	List[Any]    )		->							Union[str, Any]:
          # pipeline 1

          _start_torch_memory_measurement()

          __UpperCAmelCase			:				Dict													=    floats_tensor((1, 3, 64, 64)							,				rng=random.Random(0    )    ).to(snake_case    )

          __UpperCAmelCase			:				Union[str, Any]													=    torch.Generator(device='''cpu'''    ).manual_seed(0    )

          __UpperCAmelCase			:				Optional[Any]													=    pipe_a(
              prompt_embeds=snake_case							,				negative_prompt_embeds=snake_case							,				image=snake_case							,				num_inference_steps=2							,				generator=snake_case							,				output_type='''np'''							,				)

          __UpperCAmelCase			:				str													=    output.images[0]

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

          __UpperCAmelCase			:				Optional[int]													=    torch.cuda.max_memory_allocated()
          assert mem_bytes < 10 * 10**9

          __UpperCAmelCase			:				int													=    load_numpy(
              '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy'''    )
          assert_mean_pixel_difference(snake_case							,				snake_case    )

          # pipeline 2

          _start_torch_memory_measurement()

          __UpperCAmelCase			:				List[str]													=    torch.Generator(device='''cpu'''    ).manual_seed(0    )

          __UpperCAmelCase			:				Optional[Any]													=    floats_tensor((1, 3, 256, 256)							,				rng=random.Random(0    )    ).to(snake_case    )
          __UpperCAmelCase			:				List[Any]													=    floats_tensor((1, 3, 64, 64)							,				rng=random.Random(0    )    ).to(snake_case    )

          __UpperCAmelCase			:				str													=    pipe_a(
              prompt_embeds=snake_case							,				negative_prompt_embeds=snake_case							,				image=snake_case							,				original_image=snake_case							,				generator=snake_case							,				num_inference_steps=2							,				output_type='''np'''							,				)

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

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

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

          __UpperCAmelCase			:				Union[str, 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(snake_case							,				snake_case    )






     def 				lowerCamelCase__				(       self  :	str							,				snake_case  :	List[Any]							,				snake_case  :	Any							,				snake_case  :	Optional[int]							,				snake_case  :	int    )		->							Tuple:
          # pipeline 1

          _start_torch_memory_measurement()

          __UpperCAmelCase			:				int													=    floats_tensor((1, 3, 64, 64)							,				rng=random.Random(0    )    ).to(snake_case    )
          __UpperCAmelCase			:				str													=    floats_tensor((1, 3, 64, 64)							,				rng=random.Random(1    )    ).to(snake_case    )

          __UpperCAmelCase			:				Union[str, Any]													=    torch.Generator(device='''cpu'''    ).manual_seed(0    )
          __UpperCAmelCase			:				int													=    pipe_a(
              prompt_embeds=snake_case							,				negative_prompt_embeds=snake_case							,				image=snake_case							,				mask_image=snake_case							,				num_inference_steps=2							,				generator=snake_case							,				output_type='''np'''							,				)

          __UpperCAmelCase			:				Any													=    output.images[0]

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

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

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

          # pipeline 2

          _start_torch_memory_measurement()

          __UpperCAmelCase			:				Any													=    torch.Generator(device='''cpu'''    ).manual_seed(0    )

          __UpperCAmelCase			:				List[str]													=    floats_tensor((1, 3, 64, 64)							,				rng=random.Random(0    )    ).to(snake_case    )
          __UpperCAmelCase			:				Tuple													=    floats_tensor((1, 3, 256, 256)							,				rng=random.Random(0    )    ).to(snake_case    )
          __UpperCAmelCase			:				Any													=    floats_tensor((1, 3, 256, 256)							,				rng=random.Random(1    )    ).to(snake_case    )

          __UpperCAmelCase			:				Tuple													=    pipe_a(
              prompt_embeds=snake_case							,				negative_prompt_embeds=snake_case							,				image=snake_case							,				mask_image=snake_case							,				original_image=snake_case							,				generator=snake_case							,				num_inference_steps=2							,				output_type='''np'''							,				)

          __UpperCAmelCase			:				Optional[int]													=    output.images[0]

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

          __UpperCAmelCase			:				str													=    torch.cuda.max_memory_allocated()
          assert mem_bytes < 4 * 10**9

          __UpperCAmelCase			:				List[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(snake_case							,				snake_case    )




def 			_a			(		):





     '''simple docstring'''






     torch.cuda.empty_cache()
     torch.cuda.reset_max_memory_allocated()
     torch.cuda.reset_peak_memory_stats()








'''simple docstring'''



def 			_a			(		_lowercase      :			list[list[int]]    ,      _lowercase      :			int    ,      _lowercase      :			int    ,      _lowercase      :			set						):





     '''simple docstring'''






     __UpperCAmelCase							,     __UpperCAmelCase			:				Any													=    len(_lowercase						), len(grid[0]						)
     if (
         min(_lowercase    ,      _lowercase						) < 0
         or row == row_length
         or col == col_length
         or (row, col) in visit
         or grid[row][col] == 1
     ):
          return 0
     if row == row_length - 1 and col == col_length - 1:
          return 1

     visit.add((row, col)						)

     __UpperCAmelCase			:				Optional[Any]													=    0
     count += depth_first_search(_lowercase    ,      row + 1    ,      _lowercase    ,      _lowercase						)
     count += depth_first_search(_lowercase    ,      row - 1    ,      _lowercase    ,      _lowercase						)
     count += depth_first_search(_lowercase    ,      _lowercase    ,      col + 1    ,      _lowercase						)
     count += depth_first_search(_lowercase    ,      _lowercase    ,      col - 1    ,      _lowercase						)

     visit.remove((row, col)						)
     return count


if __name__ == "__main__":
      import doctest

      doctest.testmod()