





"""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 __magic_name__   (       __lowerCAmelCase    ,__lowerCAmelCase    ,unittest.TestCase		):
       UpperCamelCase    :						List[str]      =	IFPipeline
       UpperCamelCase    :						List[str]      =	TEXT_TO_IMAGE_PARAMS - {'''width''', '''height''', '''latents'''}
       UpperCamelCase    :						Optional[Any]      =	TEXT_TO_IMAGE_BATCH_PARAMS
       UpperCamelCase    :						Any      =	PipelineTesterMixin.required_optional_params - {'''latents'''}
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         return self._get_dummy_components()
       def 		_lowerCamelCase   (     self   ,  __magic_name__   ,  __magic_name__=0	):





         """simple docstring"""


         if str(_UpperCAmelCase	).startswith('mps'	):
           _lowerCAmelCase	      =					torch.manual_seed(_UpperCAmelCase	)
         else:
           _lowerCAmelCase	      =					torch.Generator(device=_UpperCAmelCase	).manual_seed(_UpperCAmelCase	)

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

         return inputs
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         self._test_save_load_optional_components()
       @unittest.skipIf(torch_device != 'cuda'   ,  reason='float16 requires CUDA'	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         super().test_save_load_floataa(expected_max_diff=1e-1	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2	)
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         self._test_save_load_local()
       def 		_lowerCamelCase   (     self	):





         """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 		_lowerCamelCase   (     self	):





         """simple docstring"""


         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3	)





@slow
@require_torch_gpu
class __magic_name__   (       unittest.TestCase		):
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()
       def 		_lowerCamelCase   (     self	):





         """simple docstring"""


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

         _lowerCAmelCase	      =					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	      =					pipe_a.encode_prompt('anime turtle'   ,  device='cuda'	)

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

         _lowerCAmelCase	      =					None
         _lowerCAmelCase	      =					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	      =					IFImgaImgPipeline(**pipe_a.components	)
         _lowerCAmelCase	      =					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	      =					IFInpaintingPipeline(**pipe_a.components	)
         _lowerCAmelCase	      =					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   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__	):





         """simple docstring"""


         _start_torch_memory_measurement()

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

         _lowerCAmelCase	      =					output.images[0]

         assert image.shape == (6_4, 6_4, 3)

         _lowerCAmelCase	      =					torch.cuda.max_memory_allocated()
         assert mem_bytes < 1_3 * 1_0**9

         _lowerCAmelCase	      =					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	      =					torch.Generator(device='cpu'	).manual_seed(0	)

         _lowerCAmelCase	      =					floats_tensor((1, 3, 6_4, 6_4)   ,  rng=random.Random(0	)	).to(_UpperCAmelCase	)

         _lowerCAmelCase	      =					pipe_a(
             prompt_embeds=_UpperCAmelCase   ,  negative_prompt_embeds=_UpperCAmelCase   ,  image=_UpperCAmelCase   ,  generator=_UpperCAmelCase   ,  num_inference_steps=2   ,  output_type='np'   ,  )

         _lowerCAmelCase	      =					output.images[0]

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

         _lowerCAmelCase	      =					torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 1_0**9

         _lowerCAmelCase	      =					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   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__	):





         """simple docstring"""


         _start_torch_memory_measurement()

         _lowerCAmelCase	      =					floats_tensor((1, 3, 6_4, 6_4)   ,  rng=random.Random(0	)	).to(_UpperCAmelCase	)

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

         _lowerCAmelCase	      =					pipe_a(
             prompt_embeds=_UpperCAmelCase   ,  negative_prompt_embeds=_UpperCAmelCase   ,  image=_UpperCAmelCase   ,  num_inference_steps=2   ,  generator=_UpperCAmelCase   ,  output_type='np'   ,  )

         _lowerCAmelCase	      =					output.images[0]

         assert image.shape == (6_4, 6_4, 3)

         _lowerCAmelCase	      =					torch.cuda.max_memory_allocated()
         assert mem_bytes < 1_0 * 1_0**9

         _lowerCAmelCase	      =					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	      =					torch.Generator(device='cpu'	).manual_seed(0	)

         _lowerCAmelCase	      =					floats_tensor((1, 3, 2_5_6, 2_5_6)   ,  rng=random.Random(0	)	).to(_UpperCAmelCase	)
         _lowerCAmelCase	      =					floats_tensor((1, 3, 6_4, 6_4)   ,  rng=random.Random(0	)	).to(_UpperCAmelCase	)

         _lowerCAmelCase	      =					pipe_a(
             prompt_embeds=_UpperCAmelCase   ,  negative_prompt_embeds=_UpperCAmelCase   ,  image=_UpperCAmelCase   ,  original_image=_UpperCAmelCase   ,  generator=_UpperCAmelCase   ,  num_inference_steps=2   ,  output_type='np'   ,  )

         _lowerCAmelCase	      =					output.images[0]

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

         _lowerCAmelCase	      =					torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 1_0**9

         _lowerCAmelCase	      =					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   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__	):





         """simple docstring"""


         _start_torch_memory_measurement()

         _lowerCAmelCase	      =					floats_tensor((1, 3, 6_4, 6_4)   ,  rng=random.Random(0	)	).to(_UpperCAmelCase	)
         _lowerCAmelCase	      =					floats_tensor((1, 3, 6_4, 6_4)   ,  rng=random.Random(1	)	).to(_UpperCAmelCase	)

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

         _lowerCAmelCase	      =					output.images[0]

         assert image.shape == (6_4, 6_4, 3)

         _lowerCAmelCase	      =					torch.cuda.max_memory_allocated()
         assert mem_bytes < 1_0 * 1_0**9

         _lowerCAmelCase	      =					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	      =					torch.Generator(device='cpu'	).manual_seed(0	)

         _lowerCAmelCase	      =					floats_tensor((1, 3, 6_4, 6_4)   ,  rng=random.Random(0	)	).to(_UpperCAmelCase	)
         _lowerCAmelCase	      =					floats_tensor((1, 3, 2_5_6, 2_5_6)   ,  rng=random.Random(0	)	).to(_UpperCAmelCase	)
         _lowerCAmelCase	      =					floats_tensor((1, 3, 2_5_6, 2_5_6)   ,  rng=random.Random(1	)	).to(_UpperCAmelCase	)

         _lowerCAmelCase	      =					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	      =					output.images[0]

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

         _lowerCAmelCase	      =					torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 1_0**9

         _lowerCAmelCase	      =					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     A__			(       ):





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









"""simple docstring"""

import math
from datetime import datetime, timedelta






def 		_snake_case	(   _snake_case				:   int				)       ->   datetime:






      '''simple docstring'''


      _A     =  year % 19
      _A     =  year % 4
      _A     =  year % 7
      _A     =  math.floor(year / 1_00				)
      _A     =  math.floor((13 + 8 * leap_day_inhibits) / 25				)
      _A     =  leap_day_inhibits / 4
      _A     =  (
          15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 30
      _A     =  (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

      # days to be added to March 21
      _A     =  (19 * metonic_cycle + secular_moon_shift) % 30

      # PHM -> Paschal Full Moon
      _A     =  (
          2 * julian_leap_year
          + 4 * non_leap_year
          + 6 * days_to_add
          + century_starting_point
      ) % 7

      if days_to_add == 29 and days_from_phm_to_sunday == 6:
            return datetime(_snake_case							,    4							,    19				)
      elif days_to_add == 28 and days_from_phm_to_sunday == 6:
            return datetime(_snake_case							,    4							,    18				)
      else:
            return datetime(_snake_case							,    3							,    22				) + timedelta(
                days=int(days_to_add + days_from_phm_to_sunday				)				)


if __name__ == "__main__":
       for year in (1_994, 2_000, 2_010, 2_021, 2_023):
              a							      =     '''will be''' if year > datetime.now().year else '''was'''
              print(F'''Easter in {year} {tense} {gauss_easter(year)}''')

