




'''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(			UpperCAmelCase       , UpperCAmelCase       , unittest.TestCase      ):
 __snake_case:							str						=					IFPipeline
 __snake_case:							Optional[int]						=					TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
 __snake_case:							Optional[int]						=					TEXT_TO_IMAGE_BATCH_PARAMS
 __snake_case:							List[Any]						=					PipelineTesterMixin.required_optional_params - {'''latents'''}






 def 						_UpperCamelCase (self       :  Tuple    )       ->   str:






    """simple docstring"""


    return self._get_dummy_components()






 def 						_UpperCamelCase (self       :  List[str]    ,		a       :  str    ,		a       :  Dict=0    )       ->   int:






    """simple docstring"""


    if str(a    ).startswith('mps'    ):
       A__       =     torch.manual_seed(a    )
    else:
       A__       =     torch.Generator(device=a    ).manual_seed(a    )

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

    return inputs






 def 						_UpperCamelCase (self       :  Any    )       ->   str:






    """simple docstring"""


    self._test_save_load_optional_components()






 @unittest.skipIf(torch_device != 'cuda'    ,		reason='float16 requires CUDA'    )
 def 						_UpperCamelCase (self       :  Dict    )       ->   Any:






    """simple docstring"""


    super().test_save_load_floataa(expected_max_diff=1e-1    )






 def 						_UpperCamelCase (self       :  str    )       ->   Optional[int]:






    """simple docstring"""


    self._test_attention_slicing_forward_pass(expected_max_diff=1e-2    )






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






    """simple docstring"""


    self._test_save_load_local()






 def 						_UpperCamelCase (self       :  int    )       ->   List[Any]:






    """simple docstring"""


    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 						_UpperCamelCase (self       :  List[Any]    )       ->   Tuple:






    """simple docstring"""


    self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )




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






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






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  Optional[int]    )       ->   str:






    """simple docstring"""


    A__       =     IFPipeline.from_pretrained('DeepFloyd/IF-I-XL-v1.0'    ,		variant='fp16'    ,		torch_dtype=torch.floataa    )

    A__       =     IFSuperResolutionPipeline.from_pretrained(
        'DeepFloyd/IF-II-L-v1.0'    ,		variant='fp16'    ,		torch_dtype=torch.floataa    ,		text_encoder=a    ,		tokenizer=a    )

    # pre compute text embeddings and remove T5 to save memory

    pipe_a.text_encoder.to('cuda'    )

    A__  ,			A__       =     pipe_a.encode_prompt('anime turtle'    ,		device='cuda'    )

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

    A__       =     None
    A__       =     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(a    ,		a    ,		a    ,		a    )

    pipe_a.remove_all_hooks()
    pipe_a.remove_all_hooks()

    # img2img

    A__       =     IFImgaImgPipeline(**pipe_a.components    )
    A__       =     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(a    ,		a    ,		a    ,		a    )

    pipe_a.remove_all_hooks()
    pipe_a.remove_all_hooks()

    # inpainting

    A__       =     IFInpaintingPipeline(**pipe_a.components    )
    A__       =     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(a    ,		a    ,		a    ,		a    )






 def 						_UpperCamelCase (self       :  Any    ,		a       :  Any    ,		a       :  Union[str, Any]    ,		a       :  int    ,		a       :  Optional[Any]    )       ->   str:






    """simple docstring"""


    _start_torch_memory_measurement()

    A__       =     torch.Generator(device='cpu'    ).manual_seed(0    )
    A__       =     pipe_a(
        prompt_embeds=a    ,		negative_prompt_embeds=a    ,		num_inference_steps=2    ,		generator=a    ,		output_type='np'    ,		)

    A__       =     output.images[0]

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

    A__       =     torch.cuda.max_memory_allocated()
    assert mem_bytes < 13 * 10**9

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

    # pipeline 2

    _start_torch_memory_measurement()

    A__       =     torch.Generator(device='cpu'    ).manual_seed(0    )

    A__       =     floats_tensor((1, 3, 64, 64)    ,		rng=random.Random(0    )    ).to(a    )

    A__       =     pipe_a(
        prompt_embeds=a    ,		negative_prompt_embeds=a    ,		image=a    ,		generator=a    ,		num_inference_steps=2    ,		output_type='np'    ,		)

    A__       =     output.images[0]

    assert image.shape == (2_56, 2_56, 3)

    A__       =     torch.cuda.max_memory_allocated()
    assert mem_bytes < 4 * 10**9

    A__       =     load_numpy(
        'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy'    )
    assert_mean_pixel_difference(a    ,		a    )






 def 						_UpperCamelCase (self       :  Dict    ,		a       :  Optional[int]    ,		a       :  str    ,		a       :  str    ,		a       :  Dict    )       ->   Optional[int]:






    """simple docstring"""


    _start_torch_memory_measurement()

    A__       =     floats_tensor((1, 3, 64, 64)    ,		rng=random.Random(0    )    ).to(a    )

    A__       =     torch.Generator(device='cpu'    ).manual_seed(0    )

    A__       =     pipe_a(
        prompt_embeds=a    ,		negative_prompt_embeds=a    ,		image=a    ,		num_inference_steps=2    ,		generator=a    ,		output_type='np'    ,		)

    A__       =     output.images[0]

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

    A__       =     torch.cuda.max_memory_allocated()
    assert mem_bytes < 10 * 10**9

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

    # pipeline 2

    _start_torch_memory_measurement()

    A__       =     torch.Generator(device='cpu'    ).manual_seed(0    )

    A__       =     floats_tensor((1, 3, 2_56, 2_56)    ,		rng=random.Random(0    )    ).to(a    )
    A__       =     floats_tensor((1, 3, 64, 64)    ,		rng=random.Random(0    )    ).to(a    )

    A__       =     pipe_a(
        prompt_embeds=a    ,		negative_prompt_embeds=a    ,		image=a    ,		original_image=a    ,		generator=a    ,		num_inference_steps=2    ,		output_type='np'    ,		)

    A__       =     output.images[0]

    assert image.shape == (2_56, 2_56, 3)

    A__       =     torch.cuda.max_memory_allocated()
    assert mem_bytes < 4 * 10**9

    A__       =     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(a    ,		a    )






 def 						_UpperCamelCase (self       :  Any    ,		a       :  Any    ,		a       :  List[str]    ,		a       :  int    ,		a       :  Any    )       ->   Tuple:






    """simple docstring"""


    _start_torch_memory_measurement()

    A__       =     floats_tensor((1, 3, 64, 64)    ,		rng=random.Random(0    )    ).to(a    )
    A__       =     floats_tensor((1, 3, 64, 64)    ,		rng=random.Random(1    )    ).to(a    )

    A__       =     torch.Generator(device='cpu'    ).manual_seed(0    )
    A__       =     pipe_a(
        prompt_embeds=a    ,		negative_prompt_embeds=a    ,		image=a    ,		mask_image=a    ,		num_inference_steps=2    ,		generator=a    ,		output_type='np'    ,		)

    A__       =     output.images[0]

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

    A__       =     torch.cuda.max_memory_allocated()
    assert mem_bytes < 10 * 10**9

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

    # pipeline 2

    _start_torch_memory_measurement()

    A__       =     torch.Generator(device='cpu'    ).manual_seed(0    )

    A__       =     floats_tensor((1, 3, 64, 64)    ,		rng=random.Random(0    )    ).to(a    )
    A__       =     floats_tensor((1, 3, 2_56, 2_56)    ,		rng=random.Random(0    )    ).to(a    )
    A__       =     floats_tensor((1, 3, 2_56, 2_56)    ,		rng=random.Random(1    )    ).to(a    )

    A__       =     pipe_a(
        prompt_embeds=a    ,		negative_prompt_embeds=a    ,		image=a    ,		mask_image=a    ,		original_image=a    ,		generator=a    ,		num_inference_steps=2    ,		output_type='np'    ,		)

    A__       =     output.images[0]

    assert image.shape == (2_56, 2_56, 3)

    A__       =     torch.cuda.max_memory_allocated()
    assert mem_bytes < 4 * 10**9

    A__       =     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(a    ,		a    )







def 						_A      ( ):






   '''simple docstring'''







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








'''simple docstring'''







def 						_A      ( ):






   '''simple docstring'''







   A__       =     [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

   A__       =     6
   A__       =     1
   A__       =     1901

   A__       =     0

   while year < 2001:
      day += 7

      if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
         if day > days_per_month[month - 1] and month != 2:
            month += 1
            A__       =     day - days_per_month[month - 2]
         elif day > 29 and month == 2:
            month += 1
            A__       =     day - 29
      else:
         if day > days_per_month[month - 1]:
            month += 1
            A__       =     day - days_per_month[month - 2]

      if month > 12:
         year += 1
         A__       =     1

      if year < 2001 and day == 1:
         sundays += 1
   return sundays


if __name__ == "__main__":
    print(solution())


