



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 							lowerCAmelCase_						(    a__			,       a__			,       unittest.TestCase				):
       UpperCAmelCase__							:   int  	=    IFPipeline
       UpperCAmelCase__							:   List[str]  	=    TEXT_TO_IMAGE_PARAMS - {"width", "height", "latents"}
       UpperCAmelCase__							:   List[str]  	=    TEXT_TO_IMAGE_BATCH_PARAMS
       UpperCAmelCase__							:   Optional[int]  	=    PipelineTesterMixin.required_optional_params - {"latents"}
       def    snake_case_			(     self			)	->						str:
          return self._get_dummy_components()
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_=0			)	->						Union[str, Any]:
          if str(SCREAMING_SNAKE_CASE_			).startswith('mps'			):
             UpperCamelCase       :    List[Any]		      =      torch.manual_seed(SCREAMING_SNAKE_CASE_			)
          else:
             UpperCamelCase       :    str		      =      torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(SCREAMING_SNAKE_CASE_			)

          UpperCamelCase       :    int		      =      {
              'prompt': 'A painting of a squirrel eating a burger',
              'generator': generator,
              'num_inference_steps': 2,
              'output_type': 'numpy',
          }

          return inputs
       def    snake_case_			(     self			)	->						Optional[int]:
          self._test_save_load_optional_components()
       @unittest.skipIf(torch_device != 'cuda',     reason='float16 requires CUDA'			)
       def    snake_case_			(     self			)	->						str:
          # 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    snake_case_			(     self			)	->						Dict:
          self._test_attention_slicing_forward_pass(expected_max_diff=1e-2			)
       def    snake_case_			(     self			)	->						Optional[int]:
          self._test_save_load_local()
       def    snake_case_			(     self			)	->						List[str]:
          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    snake_case_			(     self			)	->						Optional[int]:
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3			)






@slow
@require_torch_gpu
class 							lowerCAmelCase_						(    unittest.TestCase				):
       def    snake_case_			(     self			)	->						List[Any]:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()
       def    snake_case_			(     self			)	->						List[Any]:
          # if

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

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

          # pre compute text embeddings and remove T5 to save memory

          pipe_a.text_encoder.to('cuda'			)

          UpperCamelCase      ,	UpperCamelCase       :    List[str]		      =      pipe_a.encode_prompt('anime turtle',     device='cuda'			)

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

          UpperCamelCase       :    int		      =      None
          UpperCamelCase       :    Union[str, 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(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)

          pipe_a.remove_all_hooks()
          pipe_a.remove_all_hooks()

          # img2img

          UpperCamelCase       :    Optional[int]		      =      IFImgaImgPipeline(**pipe_a.components			)
          UpperCamelCase       :    List[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(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)

          pipe_a.remove_all_hooks()
          pipe_a.remove_all_hooks()

          # inpainting

          UpperCamelCase       :    Union[str, Any]		      =      IFInpaintingPipeline(**pipe_a.components			)
          UpperCamelCase       :    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(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						Any:
          # pipeline 1

          _start_torch_memory_measurement()

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

          UpperCamelCase       :    Union[str, Any]		      =      output.images[0]

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

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

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

          # pipeline 2

          _start_torch_memory_measurement()

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

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

          UpperCamelCase       :    Optional[int]		      =      pipe_a(
              prompt_embeds=SCREAMING_SNAKE_CASE_,     negative_prompt_embeds=SCREAMING_SNAKE_CASE_,     image=SCREAMING_SNAKE_CASE_,     generator=SCREAMING_SNAKE_CASE_,     num_inference_steps=2,     output_type='np',     )

          UpperCamelCase       :    Tuple		      =      output.images[0]

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

          UpperCamelCase       :    Tuple		      =      torch.cuda.max_memory_allocated()
          assert mem_bytes < 4 * 10**9

          UpperCamelCase       :    int		      =      load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'			)
          assert_mean_pixel_difference(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)
       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						List[Any]:
          # pipeline 1

          _start_torch_memory_measurement()

          UpperCamelCase       :    str		      =      floats_tensor((1, 3, 64, 64),     rng=random.Random(0			)			).to(SCREAMING_SNAKE_CASE_			)

          UpperCamelCase       :    str		      =      torch.Generator(device='cpu'			).manual_seed(0			)

          UpperCamelCase       :    Any		      =      pipe_a(
              prompt_embeds=SCREAMING_SNAKE_CASE_,     negative_prompt_embeds=SCREAMING_SNAKE_CASE_,     image=SCREAMING_SNAKE_CASE_,     num_inference_steps=2,     generator=SCREAMING_SNAKE_CASE_,     output_type='np',     )

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

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

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

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

          # pipeline 2

          _start_torch_memory_measurement()

          UpperCamelCase       :    int		      =      torch.Generator(device='cpu'			).manual_seed(0			)

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

          UpperCamelCase       :    Dict		      =      pipe_a(
              prompt_embeds=SCREAMING_SNAKE_CASE_,     negative_prompt_embeds=SCREAMING_SNAKE_CASE_,     image=SCREAMING_SNAKE_CASE_,     original_image=SCREAMING_SNAKE_CASE_,     generator=SCREAMING_SNAKE_CASE_,     num_inference_steps=2,     output_type='np',     )

          UpperCamelCase       :    Any		      =      output.images[0]

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

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

          UpperCamelCase       :    int		      =      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(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)






       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						Optional[Any]:
          # pipeline 1

          _start_torch_memory_measurement()

          UpperCamelCase       :    Dict		      =      floats_tensor((1, 3, 64, 64),     rng=random.Random(0			)			).to(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase       :    Optional[int]		      =      floats_tensor((1, 3, 64, 64),     rng=random.Random(1			)			).to(SCREAMING_SNAKE_CASE_			)

          UpperCamelCase       :    Optional[int]		      =      torch.Generator(device='cpu'			).manual_seed(0			)
          UpperCamelCase       :    Any		      =      pipe_a(
              prompt_embeds=SCREAMING_SNAKE_CASE_,     negative_prompt_embeds=SCREAMING_SNAKE_CASE_,     image=SCREAMING_SNAKE_CASE_,     mask_image=SCREAMING_SNAKE_CASE_,     num_inference_steps=2,     generator=SCREAMING_SNAKE_CASE_,     output_type='np',     )

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

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

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

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

          # pipeline 2

          _start_torch_memory_measurement()

          UpperCamelCase       :    str		      =      torch.Generator(device='cpu'			).manual_seed(0			)

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

          UpperCamelCase       :    List[Any]		      =      pipe_a(
              prompt_embeds=SCREAMING_SNAKE_CASE_,     negative_prompt_embeds=SCREAMING_SNAKE_CASE_,     image=SCREAMING_SNAKE_CASE_,     mask_image=SCREAMING_SNAKE_CASE_,     original_image=SCREAMING_SNAKE_CASE_,     generator=SCREAMING_SNAKE_CASE_,     num_inference_steps=2,     output_type='np',     )

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

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

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

          UpperCamelCase       :    Optional[int]		      =      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(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)






def 						UpperCamelCase      (  )      ->	Union[str, Any]:
   torch.cuda.empty_cache()
   torch.cuda.reset_max_memory_allocated()
   torch.cuda.reset_peak_memory_stats()






from itertools import count





def a(lowercase__ = 50						):





	'''simple docstring'''
	snake_case_   		=			[1] * min_block_length

	for n in count(lowercase__						):
		fill_count_functions.append(1						)

		for block_length in range(lowercase__      ,			n + 1						):
			for block_start in range(n - block_length						):
				fill_count_functions[n] += fill_count_functions[
				    n - block_start - block_length - 1
				]

			fill_count_functions[n] += 1

		if fill_count_functions[n] > 1000000:
			break

	return n


if __name__ == "__main__":
		print(f"""{solution() = }""")
