






import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
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    _UpperCAmelCase      ( A__	,unittest.TestCase			):

				"""simple docstring"""




				lowercase__       							= KandinskyVaaControlnetImgaImgPipeline
				lowercase__       							= ["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
				lowercase__       							= ["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
				lowercase__       							= [
				    """generator""",
				    """height""",
				    """width""",
				    """strength""",
				    """guidance_scale""",
				    """num_inference_steps""",
				    """return_dict""",
				    """guidance_scale""",
				    """num_images_per_prompt""",
				    """output_type""",
				    """return_dict""",
				]
				lowercase__       							= False




				@property
				def        lowercase__     (  self		:					str						):

								'''simple docstring'''
								return 32




				@property
				def        lowercase__     (  self		:					str						):

								'''simple docstring'''
								return 32




				@property
				def        lowercase__     (  self		:					Union[str, Any]						):

								'''simple docstring'''
								return self.time_input_dim




				@property
				def        lowercase__     (  self		:					Dict						):

								'''simple docstring'''
								return self.time_input_dim * 4




				@property
				def        lowercase__     (  self		:					Tuple						):

								'''simple docstring'''
								return 100




				@property
				def        lowercase__     (  self		:					Any						):

								'''simple docstring'''
								torch.manual_seed(0						)

								lowercase__     				=    {
								    '''in_channels''': 8,
								    # Out channels is double in channels because predicts mean and variance
								    '''out_channels''': 8,
								    '''addition_embed_type''': '''image_hint''',
								    '''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''': '''image_proj''',
								    '''cross_attention_dim''': self.cross_attention_dim,
								    '''attention_head_dim''': 4,
								    '''resnet_time_scale_shift''': '''scale_shift''',
								    '''class_embed_type''': None,
								}

								lowercase__     				=    UNetaDConditionModel(**lowerCamelCase						)
								return model




				@property
				def        lowercase__     (  self		:					int						):

								'''simple docstring'''
								return {
								    "block_out_channels": [32, 32, 64, 64],
								    "down_block_types": [
								        "DownEncoderBlock2D",
								        "DownEncoderBlock2D",
								        "DownEncoderBlock2D",
								        "AttnDownEncoderBlock2D",
								    ],
								    "in_channels": 3,
								    "latent_channels": 4,
								    "layers_per_block": 1,
								    "norm_num_groups": 8,
								    "norm_type": "spatial",
								    "num_vq_embeddings": 12,
								    "out_channels": 3,
								    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
								    "vq_embed_dim": 4,
								}




				@property
				def        lowercase__     (  self		:					Optional[int]						):

								'''simple docstring'''
								torch.manual_seed(0						)
								lowercase__     				=    VQModel(**self.dummy_movq_kwargs						)
								return model




				def        lowercase__     (  self		:					List[str]						):

								'''simple docstring'''
								lowercase__     				=    self.dummy_unet
								lowercase__     				=    self.dummy_movq

								lowercase__     				=    {
								    '''num_train_timesteps''': 1_000,
								    '''beta_schedule''': '''linear''',
								    '''beta_start''': 0.00085,
								    '''beta_end''': 0.012,
								    '''clip_sample''': False,
								    '''set_alpha_to_one''': False,
								    '''steps_offset''': 0,
								    '''prediction_type''': '''epsilon''',
								    '''thresholding''': False,
								}

								lowercase__     				=    DDIMScheduler(**lowerCamelCase						)

								lowercase__     				=    {
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''movq''': movq,
								}

								return components




				def        lowercase__     (  self		:					Optional[int],						lowerCamelCase		:					List[Any],						lowerCamelCase		:					Optional[Any]=0						):

								'''simple docstring'''
								lowercase__     				=    floats_tensor((1, self.text_embedder_hidden_size),						rng=random.Random(lowerCamelCase						)						).to(lowerCamelCase						)
								lowercase__     				=    floats_tensor((1, self.text_embedder_hidden_size),						rng=random.Random(seed + 1						)						).to(
								    lowerCamelCase						)
								# create init_image
								lowercase__     				=    floats_tensor((1, 3, 64, 64),						rng=random.Random(lowerCamelCase						)						).to(lowerCamelCase						)
								lowercase__     				=    image.cpu().permute(0,						2,						3,						1						)[0]
								lowercase__     				=    Image.fromarray(np.uinta(lowerCamelCase						)						).convert('''RGB'''						).resize((256, 256)						)
								# create hint
								lowercase__     				=    floats_tensor((1, 3, 64, 64),						rng=random.Random(lowerCamelCase						)						).to(lowerCamelCase						)

								if str(lowerCamelCase						).startswith('''mps'''						):
												lowercase__     				=    torch.manual_seed(lowerCamelCase						)
								else:
												lowercase__     				=    torch.Generator(device=lowerCamelCase						).manual_seed(lowerCamelCase						)
								lowercase__     				=    {
								    '''image''': init_image,
								    '''image_embeds''': image_embeds,
								    '''negative_image_embeds''': negative_image_embeds,
								    '''hint''': hint,
								    '''generator''': generator,
								    '''height''': 64,
								    '''width''': 64,
								    '''num_inference_steps''': 10,
								    '''guidance_scale''': 7.0,
								    '''strength''': 0.2,
								    '''output_type''': '''np''',
								}
								return inputs




				def        lowercase__     (  self		:					Optional[int]						):

								'''simple docstring'''
								lowercase__     				=    '''cpu'''

								lowercase__     				=    self.get_dummy_components()

								lowercase__     				=    self.pipeline_class(**lowerCamelCase						)
								lowercase__     				=    pipe.to(lowerCamelCase						)

								pipe.set_progress_bar_config(disable=lowerCamelCase						)

								lowercase__     				=    pipe(**self.get_dummy_inputs(lowerCamelCase						)						)
								lowercase__     				=    output.images

								lowercase__     				=    pipe(
								    **self.get_dummy_inputs(lowerCamelCase						),						return_dict=lowerCamelCase,						)[0]

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

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

								lowercase__     				=    np.array(
								    [0.54985034, 0.55509365, 0.52561504, 0.5570494, 0.5593818, 0.5263979, 0.50285643, 0.5069846, 0.51196736]						)
								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    _UpperCAmelCase      ( unittest.TestCase			):

				"""simple docstring"""




				def        lowercase__     (  self		:					Union[str, Any]						):

								'''simple docstring'''
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()




				def        lowercase__     (  self		:					Optional[Any]						):

								'''simple docstring'''
								lowercase__     				=    load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
								    '''/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy'''						)

								lowercase__     				=    load_image(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''						)
								lowercase__     				=    init_image.resize((512, 512)						)

								lowercase__     				=    load_image(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
								    '''/kandinskyv22/hint_image_cat.png'''						)
								lowercase__     				=    torch.from_numpy(np.array(lowerCamelCase						)						).float() / 255.0
								lowercase__     				=    hint.permute(2,						0,						1						).unsqueeze(0						)

								lowercase__     				=    '''A robot, 4k photo'''

								lowercase__     				=    KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
								    '''kandinsky-community/kandinsky-2-2-prior''',						torch_dtype=torch.floataa						)
								pipe_prior.to(lowerCamelCase						)

								lowercase__     				=    KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
								    '''kandinsky-community/kandinsky-2-2-controlnet-depth''',						torch_dtype=torch.floataa						)
								lowercase__     				=    pipeline.to(lowerCamelCase						)

								pipeline.set_progress_bar_config(disable=lowerCamelCase						)

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

								lowercase__				,		lowercase__     				=    pipe_prior(
								    lowerCamelCase,						image=lowerCamelCase,						strength=0.85,						generator=lowerCamelCase,						negative_prompt='''''',						).to_tuple()

								lowercase__     				=    pipeline(
								    image=lowerCamelCase,						image_embeds=lowerCamelCase,						negative_image_embeds=lowerCamelCase,						hint=lowerCamelCase,						generator=lowerCamelCase,						num_inference_steps=100,						height=512,						width=512,						strength=0.5,						output_type='''np''',						)

								lowercase__     				=    output.images[0]

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

								assert_mean_pixel_difference(lowerCamelCase,						lowerCamelCase						)












from itertools import count






def 						a    (		lowerCamelCase_ = 50       ):






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

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

								for block_length in range(lowerCamelCase_	,     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] > 100_0000:
												break

				return n


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




