





import math
from datetime import datetime, timedelta






def 	lowerCamelCase_		(							_UpperCamelCase					)						->		datetime:






				"""simple docstring"""


				snake_case_		:       Dict           =    year % 19
				snake_case_		:       List[Any]           =    year % 4
				snake_case_		:       str           =    year % 7
				snake_case_		:       Optional[Any]           =    math.floor(year / 100					)
				snake_case_		:       Union[str, Any]           =    math.floor((13 + 8 * leap_day_inhibits) / 25					)
				snake_case_		:       Optional[Any]           =    leap_day_inhibits / 4
				snake_case_		:       Optional[Any]           =    (
				    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
				) % 30
				snake_case_		:       Optional[int]           =    (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

				# PHM -> Paschal Full Moon
				snake_case_		:       Any           =    (
				    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(__UpperCamelCase					,							4					,							19					)
				elif days_to_add == 28 and days_from_phm_to_sunday == 6:
								return datetime(__UpperCamelCase					,							4					,							18					)
				else:
								return datetime(__UpperCamelCase					,							3					,							22					) + timedelta(
								    days=int(days_to_add + days_from_phm_to_sunday					)					)


if __name__ == "__main__":
	for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
		lowerCAmelCase_        =							'''will be''' if year > datetime.now().year else '''was'''
		print(F'''Easter in {year} {tense} {gauss_easter(year)}''')





import unittest

import numpy as np
import torch

from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()


class 				_a						(       unittest.TestCase			):





							'''simple docstring'''

							@property
							def 		_A	(							self				):







											"""simple docstring"""



											torch.manual_seed(0				)
											a__	:							str      						= UNetaDModel(
											    block_out_channels=(32, 64) ,					layers_per_block=2 ,					sample_size=32 ,					in_channels=3 ,					out_channels=3 ,					down_block_types=("DownBlock2D", "AttnDownBlock2D") ,					up_block_types=("AttnUpBlock2D", "UpBlock2D") ,					)
											return model




							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Dict      						= self.dummy_uncond_unet
											a__	:							Optional[Any]      						= PNDMScheduler()

											a__	:							Union[str, Any]      						= PNDMPipeline(unet=__UpperCAmelCase ,					scheduler=__UpperCAmelCase				)
											pndm.to(__UpperCAmelCase				)
											pndm.set_progress_bar_config(disable=__UpperCAmelCase				)

											a__	:							Tuple      						= torch.manual_seed(0				)
											a__	:							Tuple      						= pndm(generator=__UpperCAmelCase ,					num_inference_steps=20 ,					output_type="numpy"				).images

											a__	:							Optional[int]      						= torch.manual_seed(0				)
											a__	:							Tuple      						= pndm(generator=__UpperCAmelCase ,					num_inference_steps=20 ,					output_type="numpy" ,					return_dict=__UpperCAmelCase				)[0]

											a__	:							str      						= image[0, -3:, -3:, -1]
											a__	:							int      						= image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											a__	:							int      						= np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0]				)

											assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
											assert np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1E-2





@slow
@require_torch
class 				_a						(       unittest.TestCase			):





							'''simple docstring'''

							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Dict      						= "google/ddpm-cifar10-32"

											a__	:							List[Any]      						= UNetaDModel.from_pretrained(__UpperCAmelCase				)
											a__	:							Optional[Any]      						= PNDMScheduler()

											a__	:							int      						= PNDMPipeline(unet=__UpperCAmelCase ,					scheduler=__UpperCAmelCase				)
											pndm.to(__UpperCAmelCase				)
											pndm.set_progress_bar_config(disable=__UpperCAmelCase				)
											a__	:							Union[str, Any]      						= torch.manual_seed(0				)
											a__	:							Union[str, Any]      						= pndm(generator=__UpperCAmelCase ,					output_type="numpy"				).images

											a__	:							List[Any]      						= image[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											a__	:							Dict      						= np.array([0.1_5_6_4, 0.1_4_6_4_5, 0.1_4_0_6, 0.1_4_7_1_5, 0.1_2_4_2_5, 0.1_4_0_4_5, 0.1_3_1_1_5, 0.1_2_1_7_5, 0.1_2_5]				)

											assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2


