


UpperCAmelCase					:  Optional[int]			=						[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
UpperCAmelCase					:  int			=						[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
UpperCAmelCase					:  int			=						{
    0: "Sunday",
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday",
    4: "Thursday",
    5: "Friday",
    6: "Saturday",
}






def      __lowerCamelCase		(				lowerCamelCase__						:		int   ,				lowerCamelCase__						:		int   ,				lowerCamelCase__						:		int	):





			'''simple docstring'''




			assert len(str(SCREAMING_SNAKE_CASE_	)	) > 2, "year should be in YYYY format"
			assert 1 <= month <= 12, "month should be between 1 to 12"
			assert 1 <= day <= 31, "day should be between 1 to 31"

			# Doomsday algorithm:
			lowerCamelCase  						=   year // 100
			lowerCamelCase  						=   (5 * (century % 4) + 2) % 7
			lowerCamelCase  						=   year % 100
			lowerCamelCase  						=   centurian % 12
			lowerCamelCase  						=   (
			    (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
			) % 7
			lowerCamelCase  						=   (
			    DOOMSDAY_NOT_LEAP[month - 1]
			    if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
			    else DOOMSDAY_LEAP[month - 1]
			)
			lowerCamelCase  						=   (dooms_day + day - day_anchor) % 7
			return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
		import doctest

		doctest.testmod()







import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()
class 			a__    (					snake_case__ ,				unittest.TestCase      ):
						_a							:    Dict					=    KandinskyImgaImgPipeline
						_a							:    List[Any]					=    ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""]
						_a							:    str					=    [
						    """prompt""",
						    """negative_prompt""",
						    """image_embeds""",
						    """negative_image_embeds""",
						    """image""",
						]
						_a							:    List[Any]					=    [
						    """generator""",
						    """height""",
						    """width""",
						    """strength""",
						    """guidance_scale""",
						    """negative_prompt""",
						    """num_inference_steps""",
						    """return_dict""",
						    """guidance_scale""",
						    """num_images_per_prompt""",
						    """output_type""",
						    """return_dict""",
						]
						_a							:    int					=    False






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return 3_2






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return 3_2






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return self.time_input_dim






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return self.time_input_dim * 4






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return 1_0_0






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       XLMRobertaTokenizerFast.from_pretrained("YiYiXu/tiny-random-mclip-base"			)
											return tokenizer






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											torch.manual_seed(0			)
											__lowerCAmelCase				   =       MCLIPConfig(
											    numDims=self.cross_attention_dim		,			transformerDimensions=self.text_embedder_hidden_size		,			hidden_size=self.text_embedder_hidden_size		,			intermediate_size=3_7		,			num_attention_heads=4		,			num_hidden_layers=5		,			vocab_size=1_0_0_5		,			)

											__lowerCAmelCase				   =       MultilingualCLIP(_A			)
											__lowerCAmelCase				   =       text_encoder.eval()

											return text_encoder






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											torch.manual_seed(0			)

											__lowerCAmelCase				   =       {
											    "in_channels": 4,
											    # Out channels is double in channels because predicts mean and variance
											    "out_channels": 8,
											    "addition_embed_type": "text_image",
											    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
											    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
											    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
											    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
											    "layers_per_block": 1,
											    "encoder_hid_dim": self.text_embedder_hidden_size,
											    "encoder_hid_dim_type": "text_image_proj",
											    "cross_attention_dim": self.cross_attention_dim,
											    "attention_head_dim": 4,
											    "resnet_time_scale_shift": "scale_shift",
											    "class_embed_type": None,
											}

											__lowerCAmelCase				   =       UNetaDConditionModel(**_A			)
											return model






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return {
											    "block_out_channels": [3_2, 6_4],
											    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
											    "in_channels": 3,
											    "latent_channels": 4,
											    "layers_per_block": 1,
											    "norm_num_groups": 8,
											    "norm_type": "spatial",
											    "num_vq_embeddings": 1_2,
											    "out_channels": 3,
											    "up_block_types": [
											        "AttnUpDecoderBlock2D",
											        "UpDecoderBlock2D",
											    ],
											    "vq_embed_dim": 4,
											}






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											torch.manual_seed(0			)
											__lowerCAmelCase				   =       VQModel(**self.dummy_movq_kwargs			)
											return model






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.dummy_text_encoder
											__lowerCAmelCase				   =       self.dummy_tokenizer
											__lowerCAmelCase				   =       self.dummy_unet
											__lowerCAmelCase				   =       self.dummy_movq

											__lowerCAmelCase				   =       {
											    "num_train_timesteps": 1_0_0_0,
											    "beta_schedule": "linear",
											    "beta_start": 0.0_00_85,
											    "beta_end": 0.0_12,
											    "clip_sample": False,
											    "set_alpha_to_one": False,
											    "steps_offset": 0,
											    "prediction_type": "epsilon",
											    "thresholding": False,
											}

											__lowerCAmelCase				   =       DDIMScheduler(**_A			)

											__lowerCAmelCase				   =       {
											    "text_encoder": text_encoder,
											    "tokenizer": tokenizer,
											    "unet": unet,
											    "scheduler": scheduler,
											    "movq": movq,
											}

											return components






						def 				__SCREAMING_SNAKE_CASE(   self		,			_A		,			_A=0			):




											"""simple docstring"""



											__lowerCAmelCase				   =       floats_tensor((1, self.cross_attention_dim)		,			rng=random.Random(_A			)			).to(_A			)
											__lowerCAmelCase				   =       floats_tensor((1, self.cross_attention_dim)		,			rng=random.Random(seed + 1			)			).to(_A			)
											# create init_image
											__lowerCAmelCase				   =       floats_tensor((1, 3, 6_4, 6_4)		,			rng=random.Random(_A			)			).to(_A			)
											__lowerCAmelCase				   =       image.cpu().permute(0		,			2		,			3		,			1			)[0]
											__lowerCAmelCase				   =       Image.fromarray(np.uinta(_A			)			).convert("RGB"			).resize((2_5_6, 2_5_6)			)

											if str(_A			).startswith("mps"			):
																__lowerCAmelCase				   =       torch.manual_seed(_A			)
											else:
																__lowerCAmelCase				   =       torch.Generator(device=_A			).manual_seed(_A			)
											__lowerCAmelCase				   =       {
											    "prompt": "horse",
											    "image": init_image,
											    "image_embeds": image_embeds,
											    "negative_image_embeds": negative_image_embeds,
											    "generator": generator,
											    "height": 6_4,
											    "width": 6_4,
											    "num_inference_steps": 1_0,
											    "guidance_scale": 7.0,
											    "strength": 0.2,
											    "output_type": "np",
											}
											return inputs






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       "cpu"

											__lowerCAmelCase				   =       self.get_dummy_components()

											__lowerCAmelCase				   =       self.pipeline_class(**_A			)
											__lowerCAmelCase				   =       pipe.to(_A			)

											pipe.set_progress_bar_config(disable=_A			)

											__lowerCAmelCase				   =       pipe(**self.get_dummy_inputs(_A			)			)
											__lowerCAmelCase				   =       output.images

											__lowerCAmelCase				   =       pipe(
											    **self.get_dummy_inputs(_A			)		,			return_dict=_A		,			)[0]

											__lowerCAmelCase				   =       image[0, -3:, -3:, -1]
											__lowerCAmelCase				   =       image_from_tuple[0, -3:, -3:, -1]

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

											__lowerCAmelCase				   =       np.array(
											    [0.61_47_49_43, 0.6_07_35_39, 0.43_30_85_44, 0.5_92_82_69, 0.47_49_35_95, 0.46_75_59_73, 0.4_61_38_38, 0.45_36_87_97, 0.50_11_92_33]			)
											assert (
											    np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
											), f""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
											assert (
											    np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1E-2
											), f""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""






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






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



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






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       load_numpy(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
											    "/kandinsky/kandinsky_img2img_frog.npy"			)

											__lowerCAmelCase				   =       load_image(
											    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"			)
											__lowerCAmelCase				   =       "A red cartoon frog, 4k"

											__lowerCAmelCase				   =       KandinskyPriorPipeline.from_pretrained(
											    "kandinsky-community/kandinsky-2-1-prior"		,			torch_dtype=torch.floataa			)
											pipe_prior.to(_A			)

											__lowerCAmelCase				   =       KandinskyImgaImgPipeline.from_pretrained(
											    "kandinsky-community/kandinsky-2-1"		,			torch_dtype=torch.floataa			)
											__lowerCAmelCase				   =       pipeline.to(_A			)

											pipeline.set_progress_bar_config(disable=_A			)

											__lowerCAmelCase				   =       torch.Generator(device="cpu"			).manual_seed(0			)
											__lowerCAmelCase   ,							__lowerCAmelCase				   =       pipe_prior(
											    _A		,			generator=_A		,			num_inference_steps=5		,			negative_prompt=""		,			).to_tuple()

											__lowerCAmelCase				   =       pipeline(
											    _A		,			image=_A		,			image_embeds=_A		,			negative_image_embeds=_A		,			generator=_A		,			num_inference_steps=1_0_0		,			height=7_6_8		,			width=7_6_8		,			strength=0.2		,			output_type="np"		,			)

											__lowerCAmelCase				   =       output.images[0]

											assert image.shape == (7_6_8, 7_6_8, 3)

											assert_mean_pixel_difference(_A		,			_A			)




